本节内容
函数def： 1、位置参数，默认参数 2、位置参数，关键参数 3、如果参数中出现 *users，传递的参数就可以不再是固定的个数， 传过来的所有元素进行打包成元组 *args,**kwargs 4、非固定参数: 方式① send_alert('别他么狼了','alex','xxx','xxx','ooo') 方式② send_alert('别他么狼了',*['alex','xxx','iiii']) 5、返回值：return语句把结果返回；碰到return函数就会结束 返回只能返回一个值；当返回多个值的时候，是以元组的形式返回 6、局部变量：只定义在函数里的变量，只能在局部生效，不能在外部调用 在内部可以引用全局变量 在局部修改全局变量：global name （开发不建议用global） 7、全局变量：定义在函数外部一级代码的，全局能用 可以修改 全局变量 里的元素。---> 不可被修改的有 字符串，数字 8、在函数里修改列表内部元素：可以被修改的有：列表，字典，元组(里包含列表，字典等)集合，对象，类 不可被修改：字符串，数字 ---> 已是最小单元，内部元素不可被修改 9、嵌套函数: 多级函数 函数内部可以再定义函数，执行时需要被调用。 10、作用域：在python中，函数就一个作用域，局部变量放置在其作用域中。 代码定义完成之后，作用域已经生成，作用域链向上查找 11、匿名函数：lambda 作用：节省代码量、看着高级 例:func = lambda x,y:x*y # 声明一个匿名函数 func(3,5) 三元运算：lambda x,y:x*y if x < y else x/y map(lambda x:x**x,data) 12、高阶函数：①函数接受一个函数或多个函数作为输入 ②return 返回另一个函数 13、递归、递归的返回值： 递归的特点： ① 必须有一个明确的结束条件 ② 每次进入更深一层递归时，问题规模相比上次递归都应有所减少 ③ 递归效率不高，递归层次更多会导致栈溢出 递归与栈的关系: 每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。 由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。 求阶乘(factorial): n! = n*(n-1)! 代码如下: def factorial(n): if n == 1: return 1 return n * factorial(n-1) print(factorial(4)) 尾递归: 在调用下一次递归的时候，返回。 14、深度查询： 15、函数内置方法：abs():取绝对值、 dict():把一个数据转成字典、 help():帮助、min()取最小值、 max(): all():所有值bool都为True，只要有一个为0，就为False,空列表也为True any():与all相反、 dir():打印当前程序所有的变量、 hex():转换为16进制 slice():先定义一个列表切片的规则(没卵用)、 divmod():divmod(10,3)--->(3,1) sorted():排序，从小到大,可以自定义排序规则 ascii():（没卵用） enumerate(): oct():8进制 bin():2进制 eval():把字符串转换为代码，去其外表，取本质，只能执行一行代码 exec():与eval()相同，但可以执行多行，区别：exec()--->没有返回值 ord():返回a在ASCII的位置 chr():与ord()相反 sum():求和 bytearray():原内存地址修改字符串， map(): filter():过滤 reduce():在functools工具包里，functools.reduce print(): tuple(): callable():判断对象是否可调用（判断变量是否是函数的时候可用） len(): format(): frozenset(): vars():当前所有变量都会打印出来 locals():在函数里，打印函数当前作用域里所有的局部变量 globals(): repr():显示形式变成字符串 zip():整合两个列表的对应关系 compile(): reversed():默认翻转 complex():复数 round():保留几位小数 delattr,hasattr,getattr,setattr: hash():哈希 set():把列表变成集合 16、函数练习题：修改个人信息程序 17、函数的进阶：（鸡汤：电影--->荒野生存 ；书：百年孤独；） 命名空间(name space)： 分三种：①locals:包括局部变量和形参 ②globals：全局变量 ③builtins:内置函数模块的名字空间 不同变量的作用域不同就是由这个变量所在的命名空间决定的。 查看作用域方法：globals(),locals() 作用域的查找顺序： L:locals E:enclosing 相邻的 外部嵌套函数的名字空间 G:globals 全局变量 B:builtins 闭包： 关于闭包，即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。 而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。 当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。 也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行时， 它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。 这些局部变量、参数和函数声明（最初时）的值是外部函数返回时的值， 但也会受到内部函数的影响。 ①装饰器(语法糖)：作用：在符合开放、封闭原则下，给原有程序加新功能 ②生成器(generator)： range 底层就是一个生成器 python2 range = list xrange = 生成器 python3 range = 生成器 xrange 没有 创建方式: 1、列表 生成 式 () 2、函数 yield 作用: 返回数据，冻结当前的执行过程，并且把值返回给外面的next() 函数里有yield之后, 就会把函数名加()变成一个生成器；return 在生成器里 代表生成器的终止，直接报错 next 唤醒冻结的函数执行过程，继续执行，直到遇到下一个yield 调用next内置函数时，相当于调用了send 也发送了一个信息到生成器内部，但只能发送None 而 send 可以发送任意的值。 send 作用: 唤醒并继续执行，发送一个信息到生成器内部 sign = yield count if sign == 'stop': break # next_range.send("sop") ③迭代器: 生成器是迭代器(Iterator)对象 迭代就相当于 循环 可直接作用于for循环的数据类型，有: ①集合数据类型: 如 list tuple dict set str 等 ②generator : 包括 生成器 和 带yield的generator function. 这些可以直接作用于for循环的对象统称为可迭代对象: Iterable. 可以使用 isinstance() 判断一个对象是否是可迭代Iterable对象。 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator. 可以使用isinstance()判断一个对象是否是Iterator对象. 生成器都是Iterator对象，但列表list、字典dict、字符串str虽然是可迭代的Iterable，却不是迭代器Iterator。 把list、dict、str等Iterable变成Iterator可以使用iter()函数. >>>from collections import Iterator >>>isinstance((x for i in range(10)),Iterator) ---> True >>>isinstance([],Iterator) ---> False >>>isinstance('abc',Iterator) ---> False list,dict,str是Iterable,却不是Iterator。 把list,dict,str的Iterable变成Iterator可以使用iter()函数 >>>isinstance(iter([]),Iterator) ---> True >>>isinstance(iter('abc'),Iterator) ---> True isinstance()判断一个对象是否是可迭代(Iterable)对象. >>>from collections import Iterable >>>isinstance('abc',Iterable) ---> True 18、斐波那契数列(Figonacci): 除第一个和第二个数之外，任意一个数都可由前面两个数相加得到 a,b = 0,1 ; a,b = b,a+b 斐波那契数列用列表生成式写不出来，但是，用函数把它打印出来却很简单.
一、函数定义
什么是函数？
函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。
定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。
特点：① 减少重复代码；② 使程序变的可扩展；③ 是程序变得可维护。
语法定义：
def sayhi():#函数名
print("Hello!")
sayhi() #调用函数
可以带参数
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，指定了的话，就用你指定的值。
注意的问题：1. 只在定义时赋值一次；2. 默认参数的定义应该在位置形参右面；3. 默认参数通常应该定义成不可变类型
另外，你可能注意到了，在把country变成默认参数后，我同时把它的位置移到了最后面，为什么呢？
关键参数
正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可(指定了参数名的参数就叫关键参数)，但记住一个要求就是，关键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后。
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' )
# 这样相当于给age赋值2次，会报错！
stu_register("王山炮",22,age=25,country='JP' )
非固定参数
若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数
def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
print(name,age,args)
stu_register("hyp",22)
#输出
#hyp 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("hyp",22)
#输出
#hyp 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 = "hyp"
def change_name(name):
print("before change:",name)
name = "hyp是一个有女朋友的人"
print("after change:", name)
change_name(name)
print("在外面看看name改了么?",name)
# 输出
before change: hyp
after change: hyp是一个有女朋友的人
在外面看看name改了么? hyp
不用传name 值到函数里，也可以在函数里调用外面的变量
name = "hyp"
def change_name():
print("now name: ", name)
change_name()
print("外部的name: ", name)
# 输出
now name: hyp
外部的name: hyp
但就是不能改！
- 在函数中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
- 全局变量作用域是整个程序，局部变量作用域是定义该变量的函数。
- 当全局变量与局部变量同名时，在定义局部变量的函数内，局部变量起作用；在其它地方全局变量起作用。
作用域
作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。
如何在函数里修改全局变量？
name = "hyp"
def change_name():
global name
name = "hyp还是一名学生"
print("after change", name)
change_name()
print("在外面看看name改了么?", name)
global name的作用就是要在函数里声明全局变量name ，意味着最上面的name = "hyp"即使不写，程序最后面的print也可以打印name
嵌套函数
name = "hyp" def change_name(): name = "hyp2" def change_name2(): name = "hyp3" print("第3层打印", name) change_name2() # 调用内层函数 print("第2层打印", name) change_name() print("最外层打印", name) # 输出 第3层打印 hyp3 第2层打印 hyp2 最外层打印 hyp
匿名函数
匿名函数就是不需要显式的指定函数名
#这段代码
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)
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
只需满足以下任意一个条件，即是高阶函数
- 接受一个或多个函数作为输入
- return 返回另外一个函数
def add(x,y,f):
return f(x) + f(y)
res = add(3,-6,abs)
print(res)
递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
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）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
递归有什么用呢？递归函数实际应用案例，二分查找
data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35] def binary_search(dataset,find_num): print(dataset) if len(dataset) >1: mid = int(len(dataset)/2) if dataset[mid] == find_num: #find it print("找到数字",dataset[mid]) elif dataset[mid] > find_num :# 找的数在mid左面 print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid]) return binary_search(dataset[0:mid], find_num) else:# 找的数在mid右面 print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid]) return binary_search(dataset[mid+1:],find_num) else: if dataset[0] == find_num: #find it print("找到数字啦",dataset[0]) else: print("没的分了,要找的数字[%s]不在列表里" % find_num) binary_search(data,66)
内置函数
1.abs()【绝对值】 2.all()集合中的元素都为真的时候为真,若为空串返回为True 3.any()集合中的元素有一个为真的时候为真若为空串返回为False 4.chr()返回整数对应的ASCII字符 5.ord()返回字符对应的ASC码数字编号 6.bin(x)将整数x转换为二进制字符串 7.bool(x)返回x的布尔值 8.dir()不带参数时，返回当前范围内的变量、方法和定义的类型列表，带参数时，返回参数的属性、方法列表。 9.divmod()分别取商和余数. 10.enumerate()返回一个可枚举的对象,该对象的next()方法将返回一个tuple 11.eval()将字符串str当成有效的表达式来求值并返回计算结果。 12.filter(function, iterable)函数可以对序列做过滤处理 13.hex(x)将整数x转换为16进制字符串。 14.id()返回对象的内存地址 15.len()返回对象的长度 16.map遍历序列，对序列中每个元素进行操作，最终获取新的序列。 17.oct()八进制转换 18.range()产生一个序列，默认从0开始 19.reversed()反转 20.round()四舍五入 21.sorted()队集合排序 22.sum()对集合求和 23.type()返回该object的类型 24.vars()返回对象的变量，若无参数与dict()方法类似。 25.zip()zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。 26.reduce()对于序列内所有元素进行累计操作.
内置参数详解： https://docs.python.org/3/library/functions.html?highlight=built#ascii
几个刁钻古怪的内置方法用法提醒
#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)