函数
- 代码的一种组织形式,养成模块化思想
- 一个函数一般完成一项特定的功能,一般而言,一个函数值完成一项工作
- 函数使用
- 函数需要先定义
- 使用函数,俗称调用
# 定义一个函数
# 只是定义的话不会执行
# 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全系列教程全栈工程师”的学习