注册网站账号违法吗,百度知道官网,江苏嘉瑞通建设有限公司网站,青岛排名推广目录
前言#xff1a;
一、函数的定义
二、函数的调用
三、函数的分类
四、全局变量和局部变量
五、函数的参数
5.1 位置参数
5.2 默认值参数
5.3 可变参数
5.4 关键字参数
5.5 命名关键字参数
5.6 参数的组合
六、函数的递归 前言#xff1a; 函数就是一个过程…目录
前言
一、函数的定义
二、函数的调用
三、函数的分类
四、全局变量和局部变量
五、函数的参数
5.1 位置参数
5.2 默认值参数
5.3 可变参数
5.4 关键字参数
5.5 命名关键字参数
5.6 参数的组合
六、函数的递归 前言 函数就是一个过程、功能、动作实现一个功能或者某些功能的一个集合。 函数是一个功能或者是一个过程在python中可以将同样的代码封装成一个函数给这个函数起个名字下次用到的时候直接调用即可。
一、函数的定义
在python中定义函数的时候用到defdefine function关键字。
语法结构i
def 函数名称([参数]):#缩进函数体[return 返回值]#定义一个取绝对值的函数
def my_abs(x):if x 0:return -xelse:return x
print(my_abs(-99))
函数有返回值的情况下会根据实际情况进行返回如果函数没有返回值其实也是有返回值的只是返 回的是None
1. 如果要定义一个空函数暂时没有什么功能使用关键字pass
2. 函数的参数检查 def my_abs(x):
... if x 0:
... return -x
... else:
... return x
...my_abs(-99)
99my_abs(-99,99)
Traceback (most recent call last):File stdin, line 1, in module
TypeError: my_abs() takes 1 positional argument but 2 were givenmy_abs(-99)
Traceback (most recent call last):File stdin, line 1, in moduleFile stdin, line 2, in my_abs
TypeError: not supported between instances of str and intabs(-99)
99abs(-99)
Traceback (most recent call last):File stdin, line 1, in module
TypeError: bad operand type for abs(): str#定义一个取绝对值的函数
def my_abs(x):if not isinstance(x,(int,float)):raise TypeError(bad operand type)if x 0:return -xelse:return x
print(my_abs(-99))3.返回多个值
import math
def move(x,y,step,sngle0):nx x step math.cos(sngle)ny y step math.sin(sngle)return nx,ny
print(move(100,100,60,math.pi/6))总结函数可以返回多个值指的是return可以跟多个参数但是函数本身返回的时候只有一个是一 个元组。
import math
def move(x,y,step,sngle0):nx x step math.cos(sngle)ny y step math.sin(sngle)return nx,ny
# print(move(100,100,60,math.pi/6))
x,y move(100,100,60,math.pi/6)
print(x,y) 二、函数的调用
函数名称[参数] abs(99)
99abs(1,2)
Traceback (most recent call last):File stdin, line 1, in module
TypeError: abs() takes exactly one argument (2 given)abs(A)
Traceback (most recent call last):File stdin, line 1, in module
TypeError: bad operand type for abs(): str
函数调用的时候要注意函数参数的个数与函数的类型。 a absa(-99)
99函数名称其实是指向函数对象的引用可以把函数名称赋值给一个变量实则是给函数起了别名。
三、函数的分类
1以有无参数 有参函数、无参函数
2是否有返回值有返回值函数无、返回值函数
3按定义来分类系统自定义函数abs max min、第三方函数个人自己定义的 公司 组织
四、全局变量和局部变量
全局变量 在python中定义在py文件中的变量称为全局变量
特点代码运行的过程中始终有效
name zhangsan
局部变量 定义在函数中的变量称为局部变量
特点在函数外面是不能访问函数内的变量局部变量
name zhangsan #全局变量
def show(msg):gender 男 #局部变量print(msg)print(gender)print(name)
print(gender)
print(name)
show(哈哈哈)
# print(show(哈哈哈))print(show(哈哈哈)) ----- 打印结果为None ,因为函数没有return 。反过来说函数内部是可以访问全局变量但是不能修改全局变量如果一定要在函数内修改全局变量 的话需要使用global全局关键字但是不建议这样操作。
name zhangsan #全局变量
age 18
def show(msg):gender 男 #局部变量global ageage 1print(age)print(msg)print(gender)print(name)
# print(gender)
# print(name)
show(哈哈哈)
# print(show(哈哈哈))值传递
def add(x,y):return x y
x float(input(请输入第一个数))
y float(input(请输入第二个数))
print(add(x,y))x、y是不是不冲突add(x,y)中x和y是局部变量形参外面的x和y是实参是把实参传递给了形参 引用传递传递的是对象。
def info(fn,msg):fn()print(msg)
def print_msg():print(自己定义的函数)
print(print_msg)#代表的内存地址指向的print_msg本身代表的函数的本身
print(print_msg())#代表的是函数的返回值没有返回值返回的就是Nonedef info(fn,msg):fn()print(msg)
def print_msg():print(自己定义的函数)
# print(print_msg)#代表的内存地址指向的print_msg本身代表的函数的本身
# print(print_msg())#代表的是函数的返回值没有返回值返回的就是None
#引用传递
info(print_msg,哈哈哈哈)注意
1在强数据类型语言中函数不允许嵌套、包含函数
2在弱数据类型语言中函数是可以作为参数传递到另一个函数中
五、函数的参数
函数的参数位置参数、默认值参数、命名参数、可变参数、万能参数等
# 计算圆的周长
def get_circle_cal(r,pi):return 2 * pi * r
if __name__ __main__:r float(input(请输入圆的半径))cal get_circle_cal(r,3.14)print(半径为{}的圆的周长为{}.format(r,cal))
注意python中并不是从main函数入口的python属于脚本语言从上到下的顺序进行执行python 中main函数的目的写在main函数中的代码不会导入到其他模块中。
5.1 位置参数
def power(x):return x * x对于power(x)参数x就是一个位置参数。
def power(x,y):# return x ** ys 1while y 0:s s * xy y - 1return s
print(power(2,0))5.2 默认值参数
def power(x,y2):# return x ** ys 1while y 0:s s * xy y - 1return s
print(power(2))默认值参数就是传递的参数如果没有给参数赋值的情况的按照默认的情况进行执行函数。
默认值参数必须要写在必选参数的后面并且有多个默认值参数的情况下变化比较大的写在前变化 较小的写在后。
def add_end(L[]):L.append(END)return L
print(add_end())
print(add_end())
print(add_end())
默认值参数L指向的[][] 指的是列表代码执行的过程中[]是会发生改变的
注意1默认值参数一般要指向不可变对象 2None 是一个不可变对象
def add_end(LNone):if L is None:L []L.append(END)return L
print(add_end())
print(add_end())
print(add_end())5.3 可变参数
在python中可变参数使用*表示。可变参数的意思就是调用函数的时候可以传递参数也可以不传递参数并且传递的参数个数可以是0个或 者1个或者任意个。底层原理是将参数封装为元组进行传递的。
def calc(number):sum 0for i in number:sum i * ireturn sum
print(calc((1,2,3,4)))print(calc(1,2,3,4))def calc(*number):sum 0for i in number:sum i * ireturn sum
print(calc(1,2,3,4,5,6))
print(calc())def calc(*number):sum 0for i in number:sum i * ireturn sum
# print(calc(1,2,3,4,5,6))
# print(calc())
list [1,2,3,4]
print(calc(list[0],list[1],list[2],list[3]))
print(calc(*list))
5.4 关键字参数
底层是将参数封装为字典进行传递的
传入0个或者任意个参数
def person(name,age,**kw):print(name,name,age,age,other,kw)
person(zhangsan,18)
person(zhangsan,18,cityBeijing)用途扩展函数的功能
def person(name,age,**kw):print(name,name,age,age,other,kw)
dict {city:chongqing,job:XXX工程师}
person(lisi,20,**dict)5.5 命名关键字参数
*后面的参数就是命名关键字参数使用*将必选参数和命名关键字参数隔开如果没有传入命名关键字参数的值就会报错
def person(name,age,*,city,job):print(name,name,age,age,city,city,job,job)
person(zhangsan,18)def person(name,age,*,city,job):print(name,name,age,age,city,city,job,job)
person(zhangsan,18,citychongqing,jobXXX工程师)如果函数中已经有了可变参数了就不需要使用*,但是可变参数后面的参数依旧是命名关键字参数
def person(name,age,*args,city,job):print(name,name,age,age,city,city,job,job)
person(zhangsan,18,citychongqing,jobXXX工程师)
如果传递值的时候没有写命名关键字参数的名称的时候会报错会把传入的参数全部当作必选参数
def person(name,age,*,city,job):print(name,name,age,age,city,city,job,job)
person(zhangsan,18,chongqing,XXX工程师)命名关键字参数也可以取默认值命名关键字参数是可以出现缺省的状态
def person(name,age,*,cityBeijing,job):print(name,name,age,age,city,city,job,job)
person(zhangsan,18,jobXXX工程师)5.6 参数的组合
顺序必选参数默认值参数、可变参数、命名关键字参数、关键字参数
def f1(a,b,c0,*args,**kw):print(a,a,b,b,c,c,args,args,kw,kw)
def f2(a,b,c0,*,d,**kw):print(a,a,b,b,c,c,d,d,kw,kw)
f1(1,2)
f1(1,2,c3)
f1(1,2,3,a,b)
f1(1,2,3,a,b,X99)
f2(1,2,3,d99,X88)
args (1,2,3,4)
kw {d:99,X:88}
f1(*args,**kw)
args1 (1,2,3)
kw1 {d:99,X:88}
f2(*args1,**kw1) 六、函数的递归
在python中函数里面是可以调用其他函数的那如果调用的是自己的话就是函数的递归函数的递归就是函数自己调用自己。
前提条件
1. 函数自己调用自己
2. 要有终止条件
如果没有终止条件的情况下就会出现死循环的状态在python中会报错
def fact(n):if n 1:return 1return n * fact(n-1)
print(fact(5))fact(5)
5 * fact(5-1)
5 * 4 * fact(4-1)
5 * 4 * 3 * fact(3-1)
5 * 4 * 3 * 2 *fact(2-1)
5 * 4 * 3 * 2 * 1栈溢出的问题 ------- 尾递归优化
尾递归函数内部自己调用自己要有终止条件return语句中不能包含表达式
def fact(n):return fact_iter(n,1)
def fact_iter(num,product):if num 1:return productreturn fact_iter(num-1,num*product)
print(fact(5))fact(5)
fact_iter(5,1)
fact_iter(5-1,5*1)
fact_iter(4-1,4*5)
fact_iter(3-1,3*20)
fact_iter(2-1,2*60)
总结递归优缺点
优点逻辑简单清晰
缺点过深的递归会造成栈溢出的问题
python解释器并没有对尾递归做优化所以在python任何递归都会造成栈溢出的问题。
