函数
基本定义
函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。
定义
函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可
特性
- 减少重复代码
- 使程序变的可扩展
- 使程序变得易维护
语法定义
def sayhi():#函数名 print("Hello, I'm nobody!") sayhi() #调用函数
可以带参数
#下面这段代码 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("----注册学生信息------") print("姓名:",name) print("age:",age) print("国籍:",country) print("课程:",course) stu_register("王山炮",22,"CN","python_devops") stu_register("张叫春",21,"CN","linux") stu_register("刘老根",25,"CN","linux")
发现 country 这个参数 基本都 是"CN", 就像我们在网站上注册用户，像国籍这种信息，你不填写，默认就会是 中国， 这就是通过默认参数实现的，把country变成默认参数非常简单
def stu_register(name,age,course,country="CN"):
这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。
关键参数
正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可(指定了参数名的参数就叫关键参数)，但记住一个要求就是，关键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后
def stu_register(name, age, course='PY' ,country='CN'): print("----注册学生信息------") print("姓名:", name) print("age:", age) print("国籍:", country) print("课程:", course)
调用可以这样
stu_register("王山炮",course='PY', age=22,country='JP' )
但绝不可以这样
stu_register("王山炮",course='PY',22,country='JP' )
当然这样也不行
stu_register("王山炮",22,age=25,country='JP' )
这样相当于给age赋值2次，会报错！
非固定参数
若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数
def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式 print(name,age,args) stu_register("houxingbin",22) # 输出 # houxingbin 22 () #后面这个()就是args,只是因为没传值,所以为空 stu_register("Jack",32,"CN","Python") # 输出 # Jack 32 ('CN', 'Python')
还可以有一个**kwargs
def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式 print(name,age,args,kwargs) stu_register("houxingbin",22) # 输出 # houxingbin 22 () {} # 后面这个{}就是kwargs,只是因为没传值,所以为空 stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong") # 输出 # Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}
返回值
函数外部的代码要想获取函数的执行结果，就可以在函数里用return语句把结果返回
def stu_register(name, age, course='PY' ,country='CN'): print("----注册学生信息------") print("姓名:", name) print("age:", age) print("国籍:", country) print("课程:", course) if age > 22: return False else: return True registriation_status = stu_register("王山炮",22,course="PY全栈开发",country='JP') if registriation_status: print("注册成功") else: print("too old to be a student.")
注意
- 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
- 如果未在函数中指定return,那这个函数的返回值为None
全局与局部变量
name = "houxingbin" def change_name(name): print("before change:",name) name = "lisi" print("after change", name) change_name(name) print("在外面看看name改了么?",name)
输出
before change: houxingbin
after change lisi
在外面看看name改了么? houxingbin
不用传name 值到函数里，也可以在函数里调用外面的变量
def change_name(): name = "lisi" print("after change", name) change_name() print("在外面看看name改了么?", name)
但就是不能改！
- 在函数中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
- 全局变量作用域是整个程序，局部变量作用域是定义该变量的函数。
- 当全局变量与局部变量同名时，在定义局部变量的函数内，局部变量起作用；在其它地方全局变量起作用。
作用域
作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。
如何在函数里修改全局变量？
#!/usr/bin/env python # -*- coding:utf-8 -*- # author:HouXingbin name = "houxingbin" def change_name(): global name name = "lisi" print("after change", name) change_name() print("在外面看看name改了么?", name)
global name的作用就是要在函数里声明全局变量name ，意味着最上面的name = "Alex Li"即使不写，程序最后面的print也可以打印name
嵌套函数
#!/usr/bin/env python # -*- coding:utf-8 -*- # author:HouXingbin name = "houxingbin" def change_name(): name = "houxingbin2" def change_name2(): name = "houxingbin3" print("第3层打印", name) change_name2() # 调用内层函数 print("第2层打印", name) change_name() print("最外层打印", name)
输出
第3层打印 houxingbin3
第2层打印 houxingbin2
最外层打印 houxingbin
匿名函数
匿名函数就是不需要显式的指定函数名
# 这段代码 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
递归特性:
- 必须有一个明确的结束条件
- 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
- 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
以下用递归实现一个数的阶乘：
def factorial(n): if n == 1: return 1 return n * factorial(n-1) print(factorial(4))
尾递归
下一层和上一层已经没有关系了，在python里边没有做尾递归的优化。
def cal(n): print(n) return cal(n+1) cal(1)
内置函数
Python的len为什么你可以直接用？肯定是解释器启动时就定义好了
abs() # 取绝对值 dict() # 把一个数据转为字典 help() # 帮助 min() # 一个列表里取最小 max() # 一个列表里取最大 all() # 列表里边都是True，空列表为Flase，不为空列表每个都是True才为True any() # 列表里任意一个是True，则为True dir() # 打印当前程序的所有变量 hex() # 16进制 slice() # 定义切片的规则 divmod() # 整除，返回商和余数 sorted() # 排序 ascii() # 转成编码里的格式 enumerate() # 返回列表的索引 oct() # 八进制 bin() # 二进制 eval() # 将字符串转换成代码，只能处理单行代码，能拿到返回值 exec() # 将字符串转换成代码，能处理多行代码，但拿不到返回值 ord() # 通过字符串返回ascii码对应的位置 chr() # 通过ascii码位置返回字符 sum() # 求和 bytes() map() # 把列表里的值以此交给前边的函数处理，搭配lambda函数 filter() # 把列表里的值过滤出来，搭配lambda函数 functools.reduce() # 前两个字运算结果和第三个值运算，以此类推 In [36]: functools.reduce(lambda x,y:x+y,[1,2,3,4,52333]) Out[36]: 52343 pow() # 求次方 print() # 打印 print(s,end=",") hey , my name is houxingbin , from shandong, print("haifeng","gangniang", sep="->") haifeng->gangniang # print可直接打印到文件中 msg = "又回到最初的起点" f = open("print_tofile","w",encoding="utf-8") print(msg,"记忆中你青涩的脸",sep="|",end="",file=f) tuple() # 元组 callable() # 判断一个方法是否可调用 frozenset() # 变成一个不可变的集合 vars() # 当前所有的变量 locals() # 打印函数的局部变量 globals() # 打印全局变量 repr() # 显示成字符串 zip() # 把两个列表整合成一个列表，已最短的列表为终点 >>> a = [1,2,3,4,5] >>> b = ['a','b','c'] >>> zip(a,b) <zip object at 0x00000166B53195C8> >>> list(zip(a,b)) [(1, 'a'), (2, 'b'), (3, 'c')] compile() # 编译代码 reversed() # 翻转 complex() # 复数 round() # 保留几位小数 >>> round(3.4543354,2) 3.45 hash() # 把一个字符串变成一个数字 >>> hash("adf") 1405241256210572432 set() # 集合
几个刁钻古怪的内置方法用法提醒
#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) 几个内置方法用法提醒
浙公网安备 33010602011771号