函数
- 代码的一种组织形式，养成模块化思想
- 一个函数一般完成一项特定的功能，一般而言，一个函数值完成一项工作
- 函数使用
- 函数需要先定义
- 使用函数，俗称调用
# 定义一个函数
# 只是定义的话不会执行
# 1. def关键字，后跟一个空格
# 2. 函数名，自己定义，起名需要遵循便令命名规则，约定俗成：大驼峰命名只给类用
# 3. 后面括号和冒号不能省，括号内可以有参数，也可以没有
# 4. 函数内所有代码缩进
def func():
print("我是一个函数")
print("我要完成一定功能，要有模块化思想")
# 函数的调用
# 直接函数名后面跟括号
func()
1 函数的参数和返回值
-
参数： 负责给函数传递一些必要的数据或者信息
- 形参（形式参数）： 在函数定义的时候用到的参数没有具体值，只是一个占位的符号，成为形参
- 实参（实际参数）： 在调用函数的时候输入的值
-
返回值： 函数的执行结果
- 使用return关键字
- 如果没有return，默认返回一个None
- 函数一旦执行return语句，则无条件返回，即结束函数的执行
# 参数的定义和使用
# 参数friend只是一个符号，代表的是调用的时候的某一个数据
# 调用的时候，会用p的值代替函数中所有的person
def hello(friend):
print("{0}, 你肿么了?".format(friend))
print("需要我给你拍照吗？")
p = "阿杰"
# 调用函数，需要将p作为实参传入
hello(p)
# return语句的基本使用
# 函数打完招呼后返回一句话
#return案例1
def hello(person):
print("{0}, 今天有空吗？".format(person))
print("需要我给你拍照吗？")
return "我已经喊{0}拍照了，{0}说不去山上拍照".format(person)
p = "岳父母"
rst = hello(p) # 将return结果放在rst中
print(rst)
hello(p)
# return案例2
# 函数一旦执行return语句，则无条件返回，即结束函数的执行
def hello(person):
print("{0}, 你有空吗？".format(person))
return "哈哈，我是不会去山上的！"
print("拍照时请摆好姿势")
return "我已经喊{0}拍照了，{0}说不去山上拍照".format(person)
p = "阿杰"
rst = hello(p)
print(rst)
# 查找函数帮助文档
# 1. 用help函数
help(print)
# 2. command + 点击需要查找的函数
# 九九乘法表
# version 1.0
for row in range(1,10): # 控制外循环，从1到9
# 打印一行
for col in range(1, row+1): # 控制内循环，每次内循环从第一个数字开始
# print函数默认任务打印完毕后换行
print( row * col, end=" ")
print("----------")
# 定义一个函数，打印一行九九乘法表
def printLine(row):
for col in range(1, row+1):
# print函数默认任务打印完毕后换行
print( row * col, end=" ")
print("")
# 九九乘法表
# version 2.0
for row in range(1,10):
printLine(row)
1.1 参数详解
- 参数分类
- 普通参数
- 默认参数
- 关键字参数
- 收集参数
（1） 普通参数
-
定义的时候直接定义变量名
-
调用的时候直接把变量或者值放入指定位置
# 定义参数 def 函数名（参数1， 参数2，....): 函数体 # 调用 函数名（value1, value2,.......) # 调用的时候，具体值参考的是位置，按位置赋值
（2） 默认参数
-
形参带有默认值
-
调用的时候，如果没有对相应形参赋值，则使用默认值
# 定义参数 def func_name(p1=v1, p2=v2..........): func_block #调用1 func_name() # 调用2 value1= 100 value2=200 func_name(value1,value2)
# 普通参数案例
def normal_para(one, two, three):
print(one + two)
return None
normal_para(10, 6, 8)
# 默认参数案例1
def default_para(one, two, three=100):
print(one + two)
return None
default_para(10, 6)
# 默认参数案例2
def default_para(one, two, three=100):
print(one + two + three)
return None
default_para(10, 6)
# 默认参数示例3
'''
确认班级学生的性别
班级学生基本都是中国人，如果没有特别指定，我们默认是中国人
'''
def conf(name, age, nationality="Chinese"):
if nationality == "chinese":
print("{0} is {1}, and he is Chinese".format(name, age))
else:
print("{0} is {1}, and he is foreigner".format(name, age))
# 调用参数
conf("阿杰", 21)
conf("jay", 23, 'foreigner')
（3） 关键字参数
-
语法
定义函数： def func(p1=v1, p2=v2.....): func_body 调用函数： func(p1=value1, p2=value2.......) -
比较麻烦，但也有好处：
- 不容易混淆， 一般实参和形参只是按照位置一一对应即可，容易出错
- 使用关键字参数，可以不考虑参数位置
- 不受位置的束缚
# 关键字参数案例1
def key_para(one, two, three):
print(one + two)
return None
key_para(one=10, two=6, three=1)
key_para( two=6, three=1,one=10)
# 关键字参数案例2
## 普通参数形式
def stu(name, age, addr):
print("I am a student")
print("我叫 {0}， 我今年 {1}岁了， 我住在{2}".format(name, age, addr))
n = "Jay"
a = 25
addr = "北京市海淀区"
## 普通参数，只按照位置传递，容易出错
stu(a, n, addr)
## 关键字参数形式
def stu_key(name="No name", age=0, addr="No addr"):
print("I am a student")
print("我叫 {0}， 我今年 {1}岁了， 我住{2}".format(name, age, addr))
n = "Jay"
a = 25
addr = "北京市海淀区"
# 关键字参数，不容易出错
stu_key(age=a, name=n, addr=addr)
（4） 收集参数
-
把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结构中
-
语法
-
# 定义函数 def func(*args): func_body # 按照list使用方式访问args得到传入的参数 # 调用函数 func(p1, p2, p3, .....) -
参数名args不是必须这么写，但是，我们推荐直接用args，约定俗成
-
参数名args前需要由星号
-
收集参数可以和其他参数共存
# 收集参数案例1
# 函数模拟班级中一个学生进行自我介绍，但具体内容不清楚
# args把他看做一个list
def stu( *args):
print("Hello 大家好，我自我介绍以下，简答说两句：")
print(type(args)) # type函数作用是检测变量的类型
for item in args: # 访问list使用for循环（经典用法）
print(item)
stu("阿杰", 18, "北京海淀区", "single") # 阿杰进行自我介绍
print("*"*20)
stu("小黑") # 小黑进行自我介绍
print("*"*20)
# 说明收集参数可以不带任何实参调用，此时收集参数为空tuple
stu()
# 如果使用关键字参数格式调用，会出现问题
stu(name="xiaohei")
a 收集参数—关键字收集参数
-
把关键字参数按字典格式存入收集参数
-
语法
# 定义函数 def func( **kwargs): func_body # 调用函数 func(p1=v1, p2=v2, p3=v3........) -
kwargs一般约定俗成
-
调用的时候，把多余的关键字参数放入kwargs
-
访问kwargs需要按字典格式访问
# 收集参数案例
# 自我介绍
# 调用的时候需要使用关键字参数调用
def stu( **kwargs):
# 在函数体内对于kwargs的使用不用带星号
print("Hello 大家好，我先自我介绍一下：")
print(type(kwargs))
# 对于字典的访问，python2 和python3有区别
for k,v in kwargs.items():
print(k, "---", v)
stu(name="阿杰", age=27, addr="北京海淀区", nationality="Chinese", work="resercher")
print("*" * 50)
stu(name="阿杰")
print("*" * 50)
# 收集参数可以为空案例
stu()
b 收集参数—混合调用的顺序问题
- 收集参数，关键字参数，普通参数可以混合使用
- 使用规则就是：普通参数和关键字参数优先
- 定义的时候一般找普通参数，收集参数tuple，关键字参数，收集参数dict
# 收集参数混合调用案例
# stu模拟一个学生的自我介绍
def stu(name, age, *args, hobby="没有",**kwargs): #顺序按照要求排列，这个排序较经典
print("Hello 大家好")
print("我叫 {0}， 我今年{1}大了。".format(name, age))
if hobby == "没有":
print("我没有爱好， so sorry")
else:
print("我的爱好是{0}".format(hobby))
print("*" * 20)
for i in args:
print(i)
print("*" * 30)
for k,v in kwargs.items():
print(k, "---", v)
# 开始调用函数
name = "阿杰"
age = 27
# 调用的不同格式
stu(name, age)
stu(name, age, hobby="游泳")
stu(name, age, "小白", "小黑", hobby1="游泳", hobby2="烹饪", hobby3="打游戏")
c 收集参数的解包问题
- 把参数放入list或者字典中，直接把list/dict中的值放入收集参数中
# 收集参数的解包问题
def stu(*args):
print("哈哈哈哈哈")
# n 用来表示循环次数
# 主要用来调试，并没有特殊含义
n = 0
for i in args:
print(type(i))
print(n)
n += 1
print(i)
L = ["阿杰", 19, 23, "小黑"]
# 此时的调用，我们就需要解包符号，即调用的时候前面加一个星号
stu(*L)
1.2 返回值
- 函数和过程的区别
- 有无返回值
- 需要用return显示返回内容，
- 如果没有返回，则默认返回None
- 推荐写法，无论有无返回值，最后都要以return 结束
# 返回值示例
def func_1():
print("有返回值呀")
return 1
def func_2():
print("没有返回值")
return None
f1 = func_1()
print(f1)
f2 = func_2()
print(f2)
2 函数文档
-
函数的文档的作用是对当前函数提供使用相关的参考信息
-
用来定义所编写的函数
-
文档的写法：
- 在函数内部开始的第一行使用 【三引号字符串】定义符
- 一般具有特定格式
-
文档查看
- 使用help函数，形如 help(func)
- 使用_doc_ , 参看案例
# 文档写法案例
# 函数stu是模拟一个学生的自我介绍的内容
def stu(name, age, *args):
'''
这是第一行
这是第二行
这是第三行
'''
print("This is student introduction!")
# 查看函数文档
help(stu)
print('*'*20)
stu.__doc__
def stu(name, age):
'''
这是文档的文字内容
:param name: 表示学生的姓名
:param age: 表示学生的年龄
:return: 此函数没有返回值
'''
pass
print(help(stu))
print("*" * 20)
print(stu.__doc__)
3 递归函数
- 函数直接或者间接调用自身
- 优点：简洁，理解容易
- 缺点：对递归深度有限制，消耗资源大
- python对递归深度有限制，超过限制报错
- 递归分为两个过程
- 往下调用，分解的过程
- 往上调用，综合的过程
- 递归需要注意
- 一定注意结束条件
# 递归调用深度限制代码
x = 0
# 定义函数
def fun():
global x
x += 1
print(x)
# 函数自己调用自己（出现了递归）
fun()
# 调用函数
fun()
# 递归函数的例子1
# fun_a 表示计算阶乘
def fun_a(n):
print(n)
# 递归一定要有结束条件
if n ==1:
return 1
return n * fun_a(n-1)
rst = fun_a(5)
print("f(5) = ",rst)
# 递归函数必须有结束条件，否则会无限循环
def fun_b(n):
print(n)
return n * fun_b(n-1)
rst = fun_b(100)
print("f(100) = ",rst)
# 递归函数的例子2
# 描述斐波那契额数列
# 一列数字，第一个值是1， 第二个也是1， 从第三个开始，每一个数字的值等于前两个数字出现的值的和
# 数学公式为： f(1) = 1, f(2) = 1, f(n) = f(n-1) + f(n-2)
# 例如： 1,1,2,3,5,8,13。。。。。。。。
# 下面求斐波那契数列函数有一定问题，比如n一开始就是负数，如何修正
# n表示求第n个数子的斐波那契数列的值
def fib(n):
if n == 1:
return 1
if n == 2:
return 1
return fib(n-1) + fib(n-2)
print(fib(3))
print(fib(10))
目录
上一篇：chap1-04 程序结构
下一篇：chap1-06 内置数据结构
本次笔记来自于“免费Python全系列教程全栈工程师”的学习
201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
