3函数
定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可
特性:
- 减少重复代码
- 使程序变的可扩展
- 使程序变得易维护
语法定义
def sayhi():#函数名
print("Hello")
print("my name is kris!")
sayhi() #调用函数
调用参数
def sayhi(name):#函数名
print("Hello",name)
print("my name is kris!")
sayhi("alex") #调用函数
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") def stu_register(name,age,course,country="CN"): #country="CN" 就是默认参数
def stu_register(name,age,course,country = 'CN'): #country='CN'就是默认参数 print("registriation info...") print(name,age,course,country) stu_register("alex",22,"python") stu_register("kris",23,"python","CN") stu_register("shanshan",18,"python","Korean")
关键参数 (必须放在位置参数之后)
正常情况下,给函数传参数要按顺序,不想按顺序就可以用关键参数,只需指定参数名即可(指定了参数名的参数就叫关键参数),但记住一个要求就是,关键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后
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' ) #调用
非固定参数 *args(会把多传入的参数变成一个元组形式
) **kwargs(*kwargs 会把多传入的参数变成一个dict形式
)
def send_alert(msg,*users): #如果参数出现,*users,传递的参数就可以不再是固定个数,传过来的所有参数打包元组。 # *users是非主流的,*args才是主流。
for u in users:
print('报警发送给',u)
send_alert('别他么狠了' , ‘alex’, 'rain' ,'xxx' ) #后边三个打包成元组传递
def send_alert(msg,*users,age): for u in users: print('报警发送给',u) #如果参数中出现*users,传递的参数就可以不再是固定个数,传过来的所有参数打包元组。 #方式一 send_alert('别他么狠了' , ‘alex’, 'rain' ,'xxx' ) #方式二 send_alert('别他么狠了' , *[‘alex’, 'rain' ,'xxx'] ) #([‘alex’, 'rain' ,'xxx'] ) ------>(‘alex’, 'rain' ,'xxx') send_alert("alex","rain","eric",age=22) # "rain","eric" 它们一块传给了*users
**kwargs 是关键字参数(未定义的),指定的那个参数名。
def func(name,*args,**kwargs):
print(name,args,kwargs) #输出 alex (22 , 'tesla' , '500w') {'num':123444332 , 'addr':'山东'}
func('alex' ,22 ,'tesla' , '500w' , addr = '山东' , num = 123444332)
def func(name,*args,**kwargs): print(name,args,kwargs) #输出 alex (22 , 'tesla' , '500w') {'num':123444332 , 'addr':'山东'} # jack () {'degree': 'primary school'} func('alex' ,22 ,'tesla' , '500w' , addr = '山东' , num = 123444332) d = { 'degree':'primary school' } func('jack' ,**d)
返回值 (return代表函数的终值)
外部的代码要想获取函数的执行结果,就可以在函数里用return语句把结果返回;return语句退出函数,并返回一个表达式。不带参数值的return语句返回None
局部变量
定义在函数外部一级代码的变量,叫全局变量,全局能用; 局部变量就是指定义在函数里的变量,只能在局部生效; 在函数内部,可以引用全局变量;
如果全局和局部都有一个变量叫name,函数查找变量的顺序是由内而外的。
name = "Black girl" def change_name(): name = "黑色姑娘" print("在" ,name ,"里面...") #打印: 在 黑色姑娘 里面.... change_name() print(name) #打印: Black girl
里边可以调用外边,但是不能修改。外边不能调用里边的变量。 局部只能引用全局,是修改不了的 .
name = "Black girl"
def change_name():
#name = "黑色姑娘"
print("在" ,name ,"里面..." ,id(name) ) #打印:
def func2():
name = "rain"
func2()
charge_name()
print(name,id(name)) #打印: Black girl
在函数里修改全局变量(整体改,要加global)
name = "Black girl" def change_name(): global name #改为全局 name = "黑色的姑娘" age = 25 print("在" ,name ,"里面...", id(name)) change_name() print(name, id(name) )
在函数里修改列表数据 字典、列表、集合、类,不可以修改的有字符串
names = ['alex' , 'black girl' , 'peiqi' ]
def change_name():
del names[2]
names[1] = "黑姑娘" #整体不可以修改,但里边内部可以改
print(names)
change_name()
print(names)
嵌套函数
#嵌套函数 #1 def func1(): print('alex') def func2(): print('eric') #它没有被调用所以就不会输出eric func1() #输出alex #2 def func1(): print('alex') def func2(): print('eric') func2() func1() #输出alex eric # ====>1.函数内部可以再次定义函数。 2.执行需要被调用
#3
def func1():
age = 73
print(age)
def func2():
print(age) #它会去父级找
func2()
func1() #输出 73 73
自己没有,就去父级找,没有再去爷爷级。由内向往,一层层的找。局部变量之间也是有等级关系的。
age = 19 def func1(): age = 73 def func2(): print(age) #输出 73 func2() func1() age = 19 def func1(): def func2(): print(age) #输出73 age = 73 #程序是从上往下读的,先读age,再去调用func2() func2() func1() age = 19 def func1(): global age #把age=19拿回了 def func2(): print(age) #19 func2() #当程序走到这的时候,调用func2()然后往上走,输入age=19,再往下走age=73 age = 73 #73 它已经是全局了 func1() print(age) #73 age = 19 def func1(): global age #把全局拿过来了 def func2(): print(age) #73 age = 73 #把全局的给改了,然后再往下走去执行func2() func2() func1() print(age) #73
从上往下找,代码谁先执行,掌握global
作用域
在python中一个函数就是一个作用域。 无论在任何地方调用这个函数,永远回到它最开始的地方从上执行,往上找。
python中函数就是一个作用域(javascript),局部变量放置在其作用域中;
c# Java中作用域{ };
代码完成后,作用域已经生成,作用域链向上查找。
age = 18
def func1():
age = 73
def func2():
print(age)
return 666 #返回值为666
val = func1()
print(val) #打印出 666
age = 18
def func1():
age = 73
def func2():
print(age) #打印
return func2 #返回的是一个函数,函数名作为一返回值
val = func1()
print(val) #<function func1.<locals>.func2 at 0x00000000027F1730>
age = 18 def func1(): age = 73 def func2(): print(age) #打印出 73 return func2 #返回的是一个函数 val = func1() val()#返回值func2再调用它
函数名可以当做返回值。
匿名函数
匿名函数就是不需要显式的指定函数名。 没有名字,不能调用,只是一个函数。节省代码量;看着高级。
匿名函数主要是和其它函数搭配使用的呢。
#这段代码
def calc(x,y):
return x**y
print(calc(2,5)) #32
#换成匿名函数
calc = lambda x,y:x**y
print(calc(2,5))
def calc(x,y):
return x*y
func = lambda x,y:x**y #声明一个匿名函数
print(calc(3,8)) #24
print(func(3,8)) #6561
def calc(x,y): if x < y : return x*y else: return x/y func = lambda x,y:x*y if x < y else x/y #声明一个匿名函数 ###只能用三元运算了。 print(calc(16,8)) #2 print(func(16,8)) #2
print(func(16,32)) #512
data = list(range(10)) print(data) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #for index,i in enumerate(data): # data[index] = i * i #print(data) #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] def f2(n): return n *n print(list(map(f2, data))) #map函数 #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] print(list(map(lambda x:x*x, data))) #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
##匿名函数不需要return来返回值,表达式本身结果就是返回值. lambda x,y:x+y lambda x,y,z : x+y+z lambda x,y: x if x> y else y lambda x,y=2:x+y #含默认值 a = lambda x,y=2:x+y ##调用 a(2) ##不输就使用默认值 a(2,3) >>>a = lambda *z:z ##*z返回的是一个元祖 >>> a('Testing1','Testing2') ('Testing1', 'Testing2') >>>c = lambda **Arg: Arg #arg返回的是一个字典 >>> c() {} #lambda返回的值,结合map,filter,reduce使用 >>> filter(lambda x:x%3==0,[1,2,3,4,5,6]) [3, 6] ##等价于下面的列表推导式 >>> l = [x for x in [1,2,3,4,5,6] if x%3==0] >>> l [3, 6] >>> squares = map(lambda x:x**2,range(10)) #[0,1,4,9,16,25,36,49,64,81] >>> filters = filter(lambda x:x>5 and x<50,squares) >>> filters [9, 16, 25, 36, 49] ##lambda和reduce联合使用 >>> L = [1,2,3,4] >>> sum = reduce(lambda x,y:x+y,L) >>> sum 10 ##求2-50之间的素数 #素数:只能被1或被自己整除的数 >>> nums = range(2,50) >>> for i in nums: nums = filter(lambda x:x==i or x % i,nums) >>> nums [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47] ###求两个列表元素的和 >>> a = [1,2,3,4] >>> b = [5,6,7,8] >>> map(lambda x,y:x+y, a,b) [6, 8, 10, 12] lambda和sorted联合使用 #按death名单里面,按年龄来排序 #匿名函数的值返回给key,进来排序 >>> death = [ ('James',32), ('Alies',20), ('Wendy',25)] >>> sorted(death,key=lambda age:age[1]) #按照第二个元素,索引为1排序 [('Alies', 20), ('Wendy', 25), ('James', 32)]
高阶函数
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。
def calc(x): return x*x #f = lambda x:x*x #变量指向匿名函数 f = calc #变量不光可以赋值,可以指向函数,什么都可以赋值; f() def calc(x): return x*x n = 10 calc(n) #函数的参数能接收变量
print(calc(n)) #100 def func(x,y): return x+y def calc(x): return x #x()可以执行这个函数; x=func n = func calc(n) #一个函数可以接收另一个函数作为参数
def func(x,y): return x+y def calc(x): #把func当做参数传给了x,又返回了;不返回pass也是高阶函数 return x f = calc(func) print(f(5,9)) //14; 上一步执行calc这个函数的时候把x返回了,也就是把func这个函数给返回了,返回给外部使用;相当于执行的是func(5,9)
def func2(x,y): return abs,x,y #返回另外一个函数 res = func2(3,-10) print(res)
只需满足以下任意一个条件,即是高阶函数:
- 接受一个或多个函数作为输入
- return 返回另外一个函数
def func(x,y):
return x+y
def calc(x):
return x
f = calc(func)
print(f(5,9)) //14
def func2(x,y):
return abs,x,y
res = func2(3,-10)
print(res)
递归
递归就是在函数的执行过程中调用自己。
python有一个最大递归层。
最大递归深度限制,为什么要限制呢?
通俗来讲,是因为每个函数在调用自己的时候 还没有退出,占内存,多了肯定会导致内存崩溃。
本质上讲呢,在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。
import sys print(sys.getrecursionlimit()) #python默认的最大递归层 sys.setrecursionlimit(1500) #可以给它设置递归层,让它无限递归下去会把系统给弄爆 def recursion(n): print(n) recursion(n+1) recursion(1)
def calc(n):
print(n) #10 5 2 1
if int(n/2) ==0: 加一个判断条件就不用再往下递归了
return n
return calc(int(n/2))
calc(10)
def calc(n): v = int(n/2) print(v) #5 2 1 if v > 0: calc(v) print(n)#0 1 2 5 10 它会一层层再出来,从内到外 calc(10)
递归执行过程
递归的返回值
def calc(n,count) print(n,count) #188 1 , 94.0 2 , 47.0 3, 23.5 4 , 11.75 5 if count < 5: calc(n/2,count+1) calc(188,1)
两个return的作用,最里层那个往外返回那个结果; 每一层接收它下一层的,就是里边一层返回给它上边一层的那个值
def calc(n,count) print(n,count) #打印:188 1 , 94.0 2 , 47.0 3, 23.5 4 , 11.75 5 ,res 11.75 #这样就拿到了最里层的那个结果11.75 if count < 5: return calc(n/2,count+1) else: return n res = calc(188,1) print('res' , res)
递归特性:
- 必须有一个明确的结束条件
- 每次进入更深一层递归时,问题规模相比上次递归都应有所减少
- 递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出)
堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html
递归的用途
如阶乘、二分查找
def factorial(n): if n == 1: #结束条件,最里层;倒数第二层跟这个1相乘 return 1 return n * factorial(n-1) #factorial(n-1)层层进去得到最里层结果,返回值直接用return;调用下一层时自己退出了,但它还要等着下一层的结果,所以不叫尾递归 print(factorial(5)) #120
二分查找
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("