Python--匿名、递归、生成器、高阶函数笔记

Python—函数笔记
函数：
函数：对程序逻辑进行结构化或过程化的一种编程方式//一个被封装起来具有特定功能的代码段。可以被反复调用执行。
def 函数名([形参]): # 定义函数
  “注释”
  函数体
函数名([实参]) # 执行函数
函数的创建：
定义一个函数，能够完成打印信息的功能
def printInfo():
print( ‘------------------------------------’)
printInfo() # 执行函数
返回值：
return 表示把程序流程从被调函数转向主调函数并把表达式的值带回主调函数，实现函数值的返回。执行到return就会结束当前函数。当函数中没有return时，默认返回值是None.
函数的优点：1.减少代码重复。2.保持代码的一致性。3.方便修改，可扩展性。
参数：
形参:函数的局部变量，接收函数外部的数据。
实参：调用执行函数时，给它传递的外部数据。
1、位置参数：实参的赋值和形参定义的位置一致。

def func(s,y,z):
			print("x:",x,"y:",y,"z:",z)
func(1,2,3)

2、命名参数：实参的顺序可以和形参不一致。执行函数时（形参=实参）

func(z=3,x=1,y=2)

3、默认值参数：定义函数时，给形参默认值，没有实参时，执行函数会使用默认值。
默认值形参必须定义在最右侧。

def func2(y,z,x=1):
		print(x,y,z)
func2(2,3)

4、可变长参数：当参数数量不固定时。参数名前加*，将所有实参放置到一个元组。

def my_max(*args):
		m = args[0]
		for i in args[1:]:
				if m < i:
					m = i
		return m
print(my_max(1,2,3,10,5,6))

5、可变长命名参数：当参数数量不固定时。参数名前加两个*。

def login(**kwagrs):
		for i,key in enumerate(kwagrs):
			print(i,key,kwagrs[key])

函数变量的作用域
变量的作用域就是定义的变量可以使用的代码范围。
全局变量 ：可以被所有的函数访问，除非被删除掉，否则一直存活到脚本运行结束。
局部变量：只能在函数或代码块内部被调用，引用比全局变量速度快。
在函数中想要对全局变量进行修改，要用到关键字–global。
匿名函数
定义时没有函数名的函数。临时使用一次的简单函数，一般用于给高阶函数传参。
定义函数：
lambda 参数1，参数2… : 返回值
print((lambda x,y,z:x+y+z)(1,2,3))

print ((lambda name:"hello"+name)("小明"))
add = lambda x,y : x+y
print(add(3,4))

三目运算

x=0
#值1 if 条件 else 值2 #当条件成立时返回值1，条件不成立时返回值2
s = 100 if x != 0 else 1
print(s)
print((lambda ages:"成年" if age>=18 else "未成年")(16))
input()

递归函数
在函数内部调用自己的函数。使用递归函数要有结束条件，用于退出递归。
定义函数：
def func(n):
  if n 1 or n 0:
  return 1
else:
  return n * func(n-1)
print(func(5))

def fact(n):
		if n <= 0:
			return 1
		s = n * fact(n-1)
		print(s)
		return s
fact(979)
input()

优点和缺点：
优点：定义简单，逻辑清楚。使用递归实现的使用循环也可以实现。
缺点：递归效率不高，栈的空间是有限。写函数时候不可无限递归或者递归次数不要太大。递归层数限制（998）。
生成器函数
在生成器函数使用yield关键字返回数据，yield返回一个值之后会暂停或挂起后面代码的执行，并没有结束。
生成器对象：生成器函数执行后的结果。
next（生成器对象）–>值
for i in 生成器对象：print（i）
生成器的值是一个一个返回的。
使用场景：处理大量数据，用于节省内存空间。
#元组生成器

gen2 = (i for i in range(101) if i%2==0)
print(gen2)
def func1():
		for i in range (65,91):
				yield chr(i)
gen = func1()#生成器对象
print(next(gen))
print("你好世界")
print(next(gen))
#for i in gen:
		print(i)
print(list(range(10)))

#斐波那契（兔子序列）
#0 1 1 2 3 5 8 13 21 34 55 89 144 233

def feibo(n):
		a,b = 0,1
		while a < n:
			yield a
			a,b = b,a+b
for i in feibo(100000):
		print(i)
input()

高阶函数
定义：其中一个或多个参数是函数对象，返回值是函数对象。优点：让代码编写异常灵活。

import math
def g(f,a,b):
		return f(a) + f(b)
def func1(x):
		return x ** 2
def func2(x):
		return x + 100
def func3(x):
		return math.sqrt(x)

函数+“（）”执行函数，结果是函数返回值，将函数作为高阶参数时，不能加（）

print(func1)
print(g(func1,4,9))
print(g(func2,4,9))
print(g(func3,4,9))

#返回值是高阶函数的函数

def computer(x)
		def add(y):
			return x + y
		def sub(y):
			return x - y
		def mul():
			return x * y
		def dev():
			return x / y
		def ope(y):
				if p == "+":
						return add
				elif p == "-":
						return sub
				elif p == "*":
						return mul
				if p == "/":
						return dev
			return ope

函数的柯里化–>装饰器函数
定义：不修改其他函数代码，给其他函数增加或修改功能的函数。

print(computer(4)("*")(12))
input()

1.他将原函数作为参数，2.一般在装饰器中需要定义一层或两层内部函数，3.原函数需要在装饰器内部的函数中执行，4.将内部函数作为返回值返回。

def log_info(function):
		def run(*args,**kwargs):
				print("运行结果......")
				res = function(*args,**kwargs)
				print("运行结果.....")
				if res is None:
						res = "Ok"
				return res
		return run

@装饰器函数 装饰器语法糖 function = log_info(func)

def func():
		for i in range(10）：
				print(i)
print(func)#run()
@log_info
def add(x,y):
		return x + y
print(add(1,2))

装饰器应用场景：
1.给大量函数增加相同功能时
2.日志装饰器，测试装饰器，功能增强。
#带参装饰器
案例：测试函数运行n次的平均时间的装饰器

import time
def run_time_test(n):
		def _time_test(f):
			def _test(*args,**kwargs):
				start_time = time.time()
				for i in range(n):
						s_time = time.time()
						res = f(*args,**kwargs)
						print("第{}次执行时间:{}".format(i+1,time.time()-s_time))
				t_time = time.time()-start_time
				avg_time = t_time / n
				print("{}次执行的总时间：{}，平均时间{}".format(n,t_time,avg_time))
				return res
		return _test
return _time_test

@log_info
@run_time_test(10)
def func(n):
		s = 0
		for i in range(n):
				for j in range(n):
						for k in range(n):
								s += i+j+k
		return s
print(func1(200)) #log_info(run_time_test(10)(func1))(200)
input()

五个常用高阶函数
map/reduce/filter/sorted/reversed
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
reduce把一个函数作用在一个序列[x1, x2, x3…]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
filter()函数用于过滤序列。filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序,按照字符串长度排序
闭包
1.闭包函数里面还嵌套了函数
2.包含了对外部函数作用域中变量的引用
3.内部函数包含对外部作用域而非全局作用域变量的引用，该内部函数成为闭包函数。
#闭包函数的实例
def outer( a ): # outer是外部函数
b = 10 # a和b都是外函数的临时变量
def inner(): # inner是内函数
print(a+b) #在内函数中 用到了外函数的临时变量
return inner # 外函数的返回值是内函数的引用
demo = outer(5)
demo() # 返回15