函数
函数是什么?
函数一词来源于数学,但编程中的【函数】概念,与数学中的函数是有很大不同的,编程中的函数在英文中也有很多不同的叫法。在basic中交债subroutine(子过程或子程序),在Pascal中交债procedure(过程)和function,在C中只有function,在Java里面叫着method
定义:
函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可
特性:
- 减少重复代码
- 使程序变的可扩展
- 是程序变的易维护
可以带参数:
# 下面这段代码
a, b = 5, 8
c = a ** b
print(c)
# 改成函数写
def calc(x, y):
res = x**y
return res # 返回函数执行结果
c = calc(a, b) # 结果赋值给c变量
print(c)
函数参数
参数可以让你的函数更灵活,不只能做死的动作,还可以根据调用时传参的不同来决定函数内部的执行流程
形参变量
只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参
可以是常理,变量,表达式,函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等方法使参数获得确定值。
# 默认参数
def stu_register(name, age, country, course):
print("注册学生信息".center(20, '-'))
print("姓名", name)
print("age", age)
print("国籍", country)
print("课程", course)
stu_register("张三", 22, "CN", "python")
stu_register("王五", 23, "CN", "linux")
stu_register("李四", 25, "CN", "Java")
发现 country 这个参数 基本都 是"CN",这种不填写就默认的值,可以把country变成默认参数非常简单
def stu_register(name, age, course, country = "CN" ):
这样,这个参数在调用时不指定,那默认就是CN,指定了的话,就用你指定的值。
# 关键参数
def stu_register(name, age, course='py', country="CN"):
print("注册学生信息".center(20, '-'))
print("姓名", name)
print("age", age)
print("国籍", country)
print("课程", course)
stu_register("张三", course='py', age=22, country="CN")
正常情况下,给函数传参数要按顺序,不想按顺序就可以用关键参数,指定了参数名的参数就叫关键参数,要求是:关键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后
调用可以这样:
stu_register("张三", course='py', age=22, country="CN")
但不可以这样:
stu_register("张三", course='py', 22, country="CN")
# 非固定参数
不确定用户想传入多少个参数,就可以使用非固定参数
def stu_register(name, age, *args): # *args 会把多传入的参数变成一个元组形式
print(name, age, args)
stu_register("张三", 22)
输出:
张三 22 () # 后面这个()就是args,只是因为没有传值,所以为空
stu_register("张三", 22, "CN", "python")
输出:
张三 22 ('CN', 'python')
还可以有一个**kwargs
def stu_register(name, age, *args, **kwargs): # *kwargs会把多传入的参数变成一个dict形式
print(name, age, args, kwargs)
输出:
stu_register("张三", 22, "CN", "python", sex="M", province="湖南")
# 返回值
函数外部的代码要想获取函数的执行结果,就可以在函数里用return语句把结果返回
def stu_register(name, age, course='py', country="CN"):
print("注册学生信息".center(20, '-'))
print("姓名", name)
print("age", age)
print("国籍", country)
print("课程", course)
if age > 22:
return False
else:
return True
registration_status = stu_register("张三", 22, course="python全栈开发", country="CN")
if registration_status:
print("注册成功!")
else:
print("注册信息有误!")
注意:
- 函数在执行过程中只要遇到return语句,就会停止执行并返回结果
- 如果未在函数中指定retrurn,那这个函数的返回值为None
# 全局和局部变量
name = "张三"
def change_name(name):
print("修改前的姓名:", name)
name = "张三买了一辆特斯拉"
print("修改后的姓名:", name)
change_name(name)
print("在外面看看name改了吗?", name)
输出:
修改前的姓名: 张三
修改后的姓名: 张三买了一辆特斯拉
在外面看看name改了吗? 张三
不用传name值到函数里,也可以在函数里调用外面的变量
name = "张三"
def change_name():
name = "张三买了一辆特斯拉"
print("修改后的姓名:", name)
change_name()
print("在外面看看name改了吗?", name)
但就是不能改
- 在函数中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量
- 全局变量作用域是整个程序,局部变量作用域是定义该变量的函数
- 当全局变量与局部变量同名时,在定义局部变量的函数内,局部变量起作用;在其它地方全局变量起作用
作用域
作用域:通常来说,一段程序代码中所用到的名字并不总是有效/可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域。
在函数里修改全局变量
name = "张三"
def change_name():
global name
name = "张三买了一辆特斯拉"
print("修改后的姓名:", name)
change_name()
print("在外面看看name改了吗?", name)
global name的作用就是要在函数里声明全局变量name,意味着最上面的name=“张三”,即使不写,程序最后面的print也可以打印name
# 嵌套函数
name = "张三"
def change_name():
name = "张三丰"
def change_name2():
name = "张山峰"
print("张山峰打印:", name)
change_name2() # 调用内层函数
print("第二层打印:", name)
change_name()
print("最外层打印:", name)
输出:
张山峰打印: 张山峰
第二层打印: 张三丰
最外层打印: 张三
匿名函数
匿名函数就是不需要显式的指定函数名
#这段代码
def calc(x,y):
return x**y
print(calc(2,5))
#换成匿名函数
calc = lambda x,y:x**y
print(calc(2,5))
匿名函数主要是和其它函数搭配使用的
res = map(lambda x:x**2, (1, 5, 7, 4, 8))
for i in res:
print(i)
输出
1
25
49
16
64
高阶函数
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。
def add(x, y, f):
return f(x) + f(y)
res = add(3, -6, abs)
print(res)
只需满足以下任意一个条件,即是高阶函数
- 接受一个或多个函数作为输入
- return返回另外一个函数
递归
在函数内部,可以调用其它函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。
def calc(n):
print(n)
if int(n/2) ==0:
return n
return calc(int(n/2))
calc(10)
输出
10
5
2
1
def calc(n):
v = int(n/2)
print(v)
if v > 0:
calc(v)
print(n)
calc(10)
输出
5
2
1
0
1
2
5
10
实现过程:
递归特性:
- 必须有一个明确的结束条件
- 每次进入更深一层递归时,问题规模相比上次递归都应有所减少
- 递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减少一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出)
内置函数
Python的len为什么你可以直接用?肯定是解释器启动时就定义好了
几个***钻古怪的内置方法用法提醒
#compile
f = open("函数递归.py")
data =compile(f.read(),'','exec')
exec(data)
#print
msg = "又回到最初的起点"
f = open("tofile","w")
print(msg,"记忆中你青涩的脸",sep="|",end="",file=f)
# #slice
# a = range(20)
# pattern = slice(3,8,2)
# for i in a[pattern]: #等于a[3:8:2]
# print(i)
#
#
#memoryview
#usage:
#>>> memoryview(b'abcd')
#<memory at 0x104069648>
#在进行切片并赋值数据时,不需要重新copy原列表数据,可以直接映射原数据内存,
import time
for n in (100000, 200000, 300000, 400000):
data = b'x'*n
start = time.time()
b = data
while b:
b = b[1:]
print('bytes', n, time.time()-start)
for n in (100000, 200000, 300000, 400000):
data = b'x'*n
start = time.time()
b = memoryview(data)
while b:
b = b[1:]
print('memoryview', n, time.time()-start)
几个内置方法用法提醒