上一章我们已经正式认识了函数。
你已经知道，函数可以把一段逻辑封装起来，起个名字，以后想用的时候直接调用。 这一步非常重要，因为它让代码开始从一条流水账，慢慢变成一个个有边界的小工具。
但如果函数只会做固定一件事，很快就会遇到一个问题：
它太死了。
比如你定义一个函数，只会打印一句固定欢迎语：
defsay_hello(): print('你好，欢迎学习 Python')
这当然能跑。 可你马上就会想问：
如果我要欢迎张三怎么办 如果我要欢迎李四怎么办 如果我要欢迎不同城市的人怎么办 如果我不只是想打印一句固定内容，而是想让函数根据不同输入做不同处理，又该怎么写
这时候，参数就要出场了。
再进一步，你还会发现另一个问题：
有些函数不只是要做事，还要把结果交回来。 比如：
计算两个数的和 判断成绩是否及格 把一条脏文本清洗干净 求一个列表的平均值
这些事情如果函数做完后只是自己 print 一下，其实还不够。 因为很多时候，你想要的是这个结果本身，而不是只看一眼输出。
这时候，返回值就要出场了。
所以这一章非常关键。 因为从这一章开始，函数才真正开始活起来。
前一章的函数，更像一个只会固定动作的小机器。 这一章开始，函数终于有了真正的输入和输出。
一、为什么说参数和返回值，才是函数真正的灵魂
很多人刚学函数时，会误以为：
函数就是把几行代码包起来而已。
这话不能说错，但太表面了。
真正有用的函数，不是把一段固定代码装起来。 而是：
你可以给它不同的数据 它根据这些数据去处理 然后再把结果交还给你
你看，这一下函数就不再是僵硬动作了。 它开始像一个真正能工作的工具。
比如计算加法：
你不可能只想写一个永远计算 1 加 2 的函数。 你真正想要的是：
给它任意两个数 它都能帮你算出结果
这时候，这两个数就是参数。 而算出来的和，就是返回值。
所以参数和返回值加进来之后，函数才真正像一个完整的处理过程：
输入 处理 输出
这其实就是函数最核心的运行模式。
二、什么是参数
参数，你可以先把它理解成：
函数工作时需要的原材料
比如你让厨师做菜，总得先给他食材。 你让打印机打印，总得先给它内容。 你让一个函数欢迎某个人，总得先告诉它这个人是谁。
这个先提供给函数的信息，就是参数。
看一个最简单的例子：
defsay_hello(name): print(f'你好，{name}')
这里的 name，就是参数。
它表示：
这个函数在执行时，需要一个名字 你给它谁，它就用谁
调用时可以这样写：
say_hello('张三')say_hello('李四')
输出：
你好，张三你好，李四
你会发现，这时候函数一下就灵活了。
它不再只能说固定一句话， 而是你给不同名字，它就能处理不同内容。
这就是参数最直接的作用：
让函数从固定动作，变成可适配不同输入的动作。
三、参数写在哪里
函数定义时，参数写在函数名后面的括号里。
比如：
defsay_hello(name): print(f'你好，{name}')
这里括号里的 name，就是参数位置。
你可以理解成：
这个函数先提前声明 它需要一份叫 name 的输入信息
然后，调用函数时，把真正的值传进去：
say_hello('张三')
这时候 '张三' 就会交给参数 name。
也就是说：
定义函数时写的是参数名 调用函数时给的是具体值
这个区别你一定要尽早分清。
很多新手会把这两个混在一起。 其实它们一个是占位置的名字，一个是真正传进去的数据。
四、参数名和真正传进去的值，不是一回事
看下面这段代码：
defsay_hello(name): print(f'你好，{name}')
这里的 name，只是一个变量名。 它像是函数内部留出来的一个位置。
当你调用：
say_hello('张三')
这个时候，'张三' 才是实际传进去的值。
所以可以这样理解：
name 像一个收件箱标签'张三' 才是塞进去的内容
再比如：
say_hello('李四')
这次参数 name 接到的，就是 '李四'
所以参数不是写死的数据， 而是专门用来接收外部输入的变量。
这个理解特别重要。 因为后面你会发现，函数之所以灵活，就是因为参数位置不变，但传进去的值可以不断变化。
五、没有参数的函数，和有参数的函数，到底差在哪
我们来直接对比一下。
没有参数：
defsay_hello(): print('你好，欢迎学习 Python')
它每次调用都只会打印同一句话。
有参数：
defsay_hello(name): print(f'你好，{name}')
它每次调用都可以根据传进来的名字变化。
所以区别非常明显：
没有参数的函数，像一个固定动作按钮 有参数的函数，像一个带输入口的小机器
前者当然也有用。 比如打印分隔线、显示固定菜单、输出固定提示。 但真正更常用、更强大的，往往是带参数的函数。
因为现实里的很多任务，本来就不是固定的。 而是同一类动作，要处理不同数据。
六、一个函数可以有多个参数
当然可以。
比如你想输出一个人的姓名和年龄：
defshow_info(name, age): print(f'我叫{name}，今年{age}岁')
调用：
show_info('张三', 18)show_info('李四', 20)
输出：
我叫张三，今年18岁我叫李四，今年20岁
这里的 name 和 age，就是两个参数。
也就是说，一个函数不一定只收一份输入， 它可以收多份。
比如：
姓名 年龄 城市 成绩 商品名 价格 数量
这些都可以作为参数交给函数。
只要这些信息是这个函数完成任务所需要的原材料，它们就可以变成参数。
七、多个参数时，顺序为什么很重要
看这个例子：
defshow_info(name, age): print(f'我叫{name}，今年{age}岁')
如果你这样调用：
show_info('张三', 18)
没问题。
但如果你反过来写：
show_info(18, '张三')
输出就会变成：
我叫18，今年张三岁
程序未必报错， 但结果明显不对。
因为参数是按顺序一一对应接收的。
第一个值给第一个参数 第二个值给第二个参数
所以你以后看到多个参数时，要有一个特别自然的意识：
顺序不能乱
这也是为什么上一章说，函数不仅是语法，更是在训练你整理逻辑。 因为你必须清楚，这个函数到底需要哪些信息，而且这些信息的排列和角色是什么。
八、参数让函数真正开始像“工具”了
我们来看一个更像工具的例子。
定义一个函数，计算长方形面积：
defarea(length, width): print(length * width)
调用：
area(5, 3)area(10, 4)
你会发现，这时候函数已经不像是在执行一段固定动作了。 它更像是一个真正可用的小工具。
你给它不同的长和宽， 它就帮你算出不同的面积。
这就是参数的价值。
它不是让函数多了点装饰， 而是让函数开始真正具有通用性。
以前是写死一个值。 现在是给不同输入，都能正确处理。
这是函数特别关键的一次升级。
九、但这里有个问题：只 print 结果，真的够吗
很多新手刚开始写函数时，特别喜欢这样写：
defadd(a, b): print(a + b)
调用：
add(3, 5)
输出：
8
表面看，问题不大。 因为确实算出来了。
但你很快就会发现，这种写法有个限制：
它只是把结果打印出来了 却没有真正把结果交还给外面
比如你想继续拿这个结果去做别的事：
把它再乘 2 拿去判断大小 保存到变量里 和别的函数结果拼起来
这时候，只 print 一下就不够用了。
因为 print 只是给人看， 而不是把结果交给程序继续处理。
这就是返回值存在的意义。
十、什么是返回值
返回值，你可以先把它理解成：
函数做完事之后，交回来的结果
比如你拿两个数交给函数， 它帮你算完和， 然后把这个和还给你。
这个 还回来 的结果，就是返回值。
在 Python 里，返回值通常靠 return 来实现。
看最简单的例子：
defadd(a, b):return a + b
这里的意思是：
把 a + b 的结果返回出去
调用时可以这样写：
result = add(3, 5)print(result)
输出：
8
这和刚才那个只 print 的版本看起来差不多， 但本质上差别非常大。
因为现在这个结果，被真正交还给了外面。 你可以把它存起来、继续计算、继续传给别的函数。
这才是函数更完整的输出方式。
十一、print 和 return，差别到底在哪
这个点一定要讲透。
很多新手前期最容易把 print() 和 return 混掉。
我们直接对比。
第一种：
defadd(a, b): print(a + b)
第二种：
defadd(a, b):return a + b
看起来都和加法有关。 但它们做的事完全不一样。
print() 的作用是：
把内容显示出来，给人看
return 的作用是：
把结果交还给函数外部，给程序继续用
这两者不是一个层级的东西。
一个偏显示。 一个偏传递结果。
所以以后你一定要记住一句特别重要的话：
print() 是展示return 是返回结果
很多初学者函数写不顺，核心问题就在这里没分清。
十二、一个特别直观的对比例子
先看 print 版本：
defadd(a, b): print(a + b)result = add(3, 5)print(result)
输出会是：
8None
很多人看到这里会一脸懵。
为什么又多出来一个 None？
因为 add(3, 5) 这个函数本身没有返回值。 它只是打印了 8， 但真正调用结束后，没有把结果交还出来。 所以 result 接到的是 None
再看 return 版本：
defadd(a, b):return a + bresult = add(3, 5)print(result)
输出：
8
这次就正常了。
因为函数真正返回了 a + b 的结果。 所以 result 才接到了 8。
这个对比你一定要亲手敲一遍。 它会帮你彻底分清 print 和 return 的角色。
十三、为什么 return 才是函数真正的输出
因为程序真正要的是结果，而不是只是看一眼。
比如你算两个数的和，不一定只是想打印出来。 你可能还想：
继续乘 10 判断是不是大于 100 保存起来 传给别的函数
比如：
defadd(a, b):return a + bx = add(3, 5)y = add(10, 20)print(x * 2)print(y > 25)
输出：
16True
这就是返回值的力量。
函数不再只是自己在里面干一圈然后喊一句结果。 它开始真正把结果交给外部，让整个程序继续流动起来。
所以参数和返回值一结合，函数才真正形成完整闭环：
接收输入 内部处理 交回结果
这才是函数真正成熟的形态。
十四、一个函数可以没有返回值吗
当然可以。
比如：
defshow_menu(): print('1. 登录') print('2. 注册') print('3. 退出')
这个函数的目的就是展示菜单。 它本来就不需要返回什么结果。
所以不是所有函数都必须有 return。 这要看你的函数职责是什么。
如果它只是负责展示、打印、提示， 没有返回值也很正常。
但如果它的作用是：
计算 判断 提取 转换 清洗 处理后产出一个结果
那通常就应该考虑返回值。
你可以这样简单区分：
负责“做动作”的函数，可能不一定要返回值 负责“产结果”的函数，通常更需要返回值
十五、一个函数可以返回什么
目前阶段你可以先理解成：
几乎任何类型的数据都能返回
比如返回一个数字：
defadd(a, b):return a + b
返回一个字符串：
defwelcome(name):returnf'欢迎{name}学习 Python'
返回一个布尔值：
defis_pass(score):return score >= 60
返回一个列表：
defget_names():return ['张三', '李四', '王五']
你会发现，返回值不是只局限于数字。 只要这个函数处理后的结果是什么，就可以返回什么。
这一点特别重要。 因为它说明函数不仅能算数， 还能生成文本、判断真假、提供数据结构。
这也是为什么函数能在程序里无处不在。
十六、参数和返回值放在一起，函数终于完整了
我们来看看一个真正完整的小函数：
defget_total(price, count):return price * count
这里：
price 和 count 是参数price * count 的结果是返回值
调用：
total = get_total(59.9, 3)print(total)
输出：
179.7
这个函数就非常典型。
它接收输入 完成处理 给出结果
你会发现，这时候函数已经很像现实里的机器设备了。
你投进去原材料 它加工 再把结果吐出来
这就是参数和返回值真正让函数活起来的原因。
十七、再看一个判断型函数
比如判断成绩是否及格：
defis_pass(score):return score >= 60
调用：
print(is_pass(90))print(is_pass(45))
输出：
TrueFalse
你看，这里函数没有 print 什么及格不及格的句子。 它只是老老实实返回判断结果。
这反而更好用。
因为你后面可以自己决定怎么处理这个结果：
score = 75if is_pass(score): print('及格了')else: print('没及格')
这就体现出一个非常重要的编程思想：
函数尽量只负责把结果算出来 至于这个结果怎么展示、怎么使用，可以交给外部决定
这个思路你现在先有感觉就行，后面会越来越重要。
十八、一个常见误区：什么都写进函数里
很多新手刚学到这里，容易犯一个错。
既然函数这么方便，那我把计算、判断、打印、格式化、各种事情全塞一个函数里。
能不能跑？ 当然能。
但这样写往往会让函数变得特别臃肿。
比如：
defcheck_score(score):if score >= 60: print('及格了')else: print('没及格')
这也不是错。 只是它把 判断 和 输出 展示 捆在一起了。
更灵活的写法往往是：
defis_pass(score):return score >= 60
然后外面自己决定怎么显示。
这不是绝对规则。 但它会让你的函数更通用、更容易复用。
所以你从这一章开始，要慢慢建立一个意识：
函数最好尽量职责明确 别什么都往里塞
十九、参数和返回值，正在训练你什么能力
表面上看，是在学函数。 更深一层，其实是在训练你思考：
一个小功能到底需要什么输入 又应该交出什么输出
这非常重要。
因为后面不管你写函数、写类、写模块、写接口， 核心都绕不开这两个问题：
你需要别人给你什么 你又要把什么交还出去
你会发现，这其实已经非常接近真正的软件设计思维了。
所以参数和返回值不是一个小语法点。 它是在训练你理解“输入”和“输出”的边界。
二十、来看一个非常像工具的文本清洗函数
前面字符串阶段你已经做过文本清洗。 现在我们用函数来重写这种逻辑。
比如定义一个函数，专门清洗一条简单用户信息：
defclean_text(text): text = text.strip() parts = text.split(',') result = []for item in parts: result.append(item.strip())return result
调用：
data = clean_text(' 张三 , 18 , 北京 ')print(data)
输出：
['张三', '18', '北京']
这个例子特别有味道。
因为你会发现，函数现在已经不像课堂玩具了。 它开始像一个真正能解决问题的小工具。
你给它一条脏文本 它帮你洗干净 再把结果交回来
这就是函数真正的输入和输出。
二十一、返回值为什么比你想象中更重要
因为没有返回值，很多逻辑就断掉了。
比如你想先清洗文本，再把结果转字典，再保存到列表。 如果清洗函数只是自己 print 一下，你后面的步骤根本接不上。
但如果它返回清洗后的结果，就可以继续接着写：
defclean_text(text): text = text.strip() parts = text.split(',') result = []for item in parts: result.append(item.strip())return resultdata = clean_text(' 张三 , 18 , 北京 ')student = {'name': data[0],'age': data[1],'city': data[2]}print(student)
你会发现，返回值让整个程序真正串起来了。
所以函数不是定义出来就完事。 真正让函数参与程序流转的，往往恰恰是返回值。
二十二、最容易犯的几个错
这一章坑非常多，我给你提前点出来。
第一个错，函数定义了参数，但调用时没传值。
比如：
defsay_hello(name): print(f'你好，{name}')say_hello()
这会报错。 因为函数明确说了，它需要一个名字，你却没给。
第二个错，参数个数对不上。
比如定义两个参数，却只传一个，或者传三个。 这都会有问题。
第三个错，把 print() 当成返回值。
这个前面已经讲透了，一定要分清。
第四个错，写了 return 之后，外面却不用返回结果。
比如：
defadd(a, b):return a + badd(3, 5)
虽然没错，但如果你后面不用它，这个返回值的价值就没有发挥出来。
第五个错，是函数职责太乱。 一会儿负责计算，一会儿负责打印，一会儿又负责输入，所有事情糊在一起。 这样函数会越来越难用。
二十三、这一章最该建立的，不是记忆，而是函数运行流程感
你以后看到一个函数，脑子里最好自动过这三步：
它接收什么 它内部做什么 它最后给出什么
比如：
defadd(a, b):return a + b
你就要能自然地看出：
接收 a 和 b内部做加法 返回结果
再比如：
defwelcome(name):returnf'欢迎{name}学习 Python'
你要能看出：
接收 name内部拼接字符串 返回欢迎语
这种流程感一旦建立起来， 你以后自己写函数就不容易乱。
二十四、练习题：这章一定要自己敲顺
下面这些练习非常关键，建议你一定要亲手写。
1. 定义一个函数，接收名字，打印欢迎语
defsay_hello(name): print(f'你好，{name}')say_hello('张三')say_hello('李四')
2. 定义一个函数，接收两个数，返回它们的和
defadd(a, b):return a + bresult = add(3, 5)print(result)
3. 定义一个函数，接收成绩，返回是否及格
defis_pass(score):return score >= 60print(is_pass(80))print(is_pass(45))
4. 定义一个函数，接收商品价格和数量，返回总价
defget_total(price, count):return price * countprint(get_total(29.9, 3))
5. 定义一个函数，接收一条带空格的文本，返回清洗后的结果
defclean_text(text):return text.strip()print(clean_text(' hello python '))
你把这些最基础的练习写顺以后，参数和返回值的感觉就会明显起来。
二十五、本章小结
这一章非常关键，因为从这一章开始，函数终于不再只是一个固定动作盒子了。
参数，负责把外部信息送进函数。 返回值，负责把处理结果交回外部。
它们让函数真正形成了完整闭环：
接收输入 内部处理 输出结果
你要牢牢记住几件事：
参数写在函数定义时的括号里 调用函数时传入具体值 多个参数按顺序对应print() 是展示return 是返回结果 函数到底该不该返回值，要看它有没有真正产出结果
如果上一章是让你学会把一段逻辑封装起来， 那么这一章，就是让你开始学会让这个小功能真正和外部世界发生数据交换。
这一步非常关键。 因为从现在开始，函数终于不只是能“做事”，而且能“接收信息、交出结果”了。
下一章我们继续讲 位置参数、默认参数、关键字参数，一篇讲透。 到那一章，你会发现，参数虽然已经让函数灵活起来了，但参数本身也有很多更细的讲究。
