Python学习,Day12(函数闭包,匿名函数)

# ### 闭包函数
"""
如果内函数使用了外函数的局部变量,
并且外函数把内函数返回出来的过程,叫做闭包
里面的内函数是闭包函数
"""

# 基本语法
def songyunjie_family():
	father = "王健林"
	def f_hobby():
		print("我们先顶一个小目标,比如赚它一个亿,这是我爸爸{}".format(father))
	return f_hobby

func = songyunjie_family()
func()

obj = func.__closure__[0]
print(obj.cell_contents,"<111>")



# 复杂版本
def mashengping_family():
	father = "马云"
	jiejie_name	= "马蓉"
	meimei_name = "马诺"
	money = 1000
	
	def jiejie():
		nonlocal money
		money -= 700
		print("买包包,买名表,买首饰,把钱都败光了,家里的钱还剩下{}元".format(money))
		
	def meimei():
		nonlocal money
		money -= 200
		print("要找只找有钱人,宁愿在宝马里面哭,也不愿意在自行车上撒欢,家里的败光了还剩下{}元".format(money))

	def big_master():
		return (jiejie,meimei)
	
	
	return big_master
	
func = mashengping_family()
print(func)
# 返回的是元组
tup = func() # big_master()
print(tup)   # tup =  (jiejie,meimei)
# 获取姐姐
jiejie = tup[0] # jiejie 函数
# 获取妹妹
meimei = tup[1] # meimei 函数

# big_master 是闭包函数,是直接被mashengping_family返回出来的
# jiejie,meimei 是通过big_master间接被返回到函数外面的
# 调用妹妹
meimei()  # 调用妹妹函数
# 调用姐姐
jiejie()  # 调用姐姐函数


# ### 获取闭包函数使用的变量  __closure__
res = func.__closure__
print(res,"<222>")
#  cell_contents 用来获取单元格对象当中的闭包函数
jiejie = res[0].cell_contents 
meimei = res[1].cell_contents

# 通过获取单元格对象 -> 获取单元格对象中的内容 -> 实际的调用
jiejie()
meimei()

print(jiejie.__closure__[0].cell_contents)
print(meimei.__closure__[0].cell_contents)

# ### 闭包的特征 
"""
内函数使用了外函数的局部变量
那么该变量与闭包函数发生绑定,
延长该变量的生命周期
"""
def outer(val):
	def inner(num):
		return val + num
	return inner
	
func = outer(10) # func = inner
res = func(15)   # res = func(15) = inner(15)
print(res)
"""
10实参 -> val 形参
因为内函数inner是闭包函数,使用了外函数val
那么该变量val生命周期被延长,没有随着函数调用的结束而释放.
func(15) 把15这个参数赋值给num这个形参
res = inner(15)  => return val + num =>10 + 15 => 25
"""

# ### 闭包的意义

# 模拟鼠标点击次数
num = 0
def click_num():
	global num
	num += 1
	print(num)

click_num()
click_num()
click_num()
num = 100
click_num()
click_num()

# 使用闭包函数改写点击次数
"""
闭包的意义:闭包可以优先使用外函数中的变量,并对闭包中的值起到了封装保护的作用.外部无法访问.
"""
def click_num():
	num = 0
	def func():
		nonlocal num
		num += 1
		print(num)
	return func
func = click_num()
func()
func()
num = 1000

# ### 匿名函数 : 用一句话来表达只有返回值的函数
"""语法:lambda 参数 : 返回值 """
"""追求代码:简洁,高效"""

# 1.无参的lambda 表达式
def func():
	return "123"
	
# 改写
func = lambda : "123"
res = func()
print(res)


# 2.有参的lambda 表达式
def func(n):
	return type(n)
	
# 改写	
func = lambda n : type(n)
print(  func([1,2,3])  )

# 3.带有判断条件的lambda 表达式
def func(n):
	if n % 2 == 0:
		return "偶数"
	else:
		return "奇数"		
		
func = lambda n : "偶数" if n % 2 == 0 else "奇数"
res = func(17)
print(res)


# ### 三元(目)运算符
"""
语法:
	真值 if 条件表达式 else 假值  如果条件表达式为真,返回真值,否则返回假值
"""
n = 16
res = "偶数" if n % 2 == 0 else "奇数"
print(res)


# 小练习 , 传递两个数, 返回较大的那一个
def func(x,y):
	if x>y:
		return x
	else:
		return y
		
func = lambda x,y : x if x>y else y
res = func(200,100)
print(res)

"""
1.定义函数:打印用户传入的容器类型数据长度
2.定义函数:参数为容器类型数据,打印所有奇数位索引对应的元素
3.定义函数:,接收一个参数(可迭代性数据),用_让元素相连成字符串,打印出来
4.定义函数:接收任意个参数,打印其中的最小值
5.定义函数:传入一个参数n，返回n的阶乘(5! = 5*4*3*2*1)
6.写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),
	将容器中的每个元素依次添加到新的列表中返回
	#例:传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
7.写函数，用户传入要修改的文件名，与要修改的内容，执行函数，修改操作
8.写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
9.写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，返回处理后的结果.
	#例:参数为:dic = {"k1": "v1v1", "k2": [11,22,33,44]}
10.传入多个一级容器类型数据,计算元素总个数
"""
# 1.定义函数:打印用户传入的容器类型数据长度
def func(container):
	len(container)
	
func = lambda contaner : len(contaner)
res = func([1,2,3,45])
print(res)

# 2.定义函数:参数为容器类型数据,打印所有奇数位索引对应的元素
def func(container):
	i = 0
	while i<len(container):
		if i % 2 == 1:
			print(container[i])
		i+=1
func([1,2,3,43,5,5])

# 方法二
def func(container):
	return container[1::2] # 1,3,5,7, ...
res = func([1,2,3,43,5,5])
print(res)


# 3.定义函数:,接收一个参数(可迭代性数据),用_让元素相连成字符串,打印出来
def func(container):
	return "_".join(container)
func(["1","2","3","45"])
print(res)


def func(container):
	strvar = ""
	for i in container:
		strvar += str(i) + "_"
		
	return strvar.rstrip("_")

res = func([1,2,5,7])
print(res)

# 4.定义函数:接收任意个参数,打印其中的最小值

# 正常
def func(*args):
	# print(args)
	lst = list(args)
	lst.sort()
	return lst[0]
	
res = func(1,5,9,-100)
print(res)


# 升级
def func(*args):
	lst_new = []
	print(args)
	for i in args:
		if isinstance(i,(int,float)):
			lst_new.append(i)
			
		elif isinstance(i,(list,tuple,dict,set)):
			if isinstance(i,dict):
				i = i.values()
				# print(i.values())
		
			for j in i:
				if isinstance(j,(int,float)):
					lst_new.append(j)
	lst_new.sort()		
	return lst_new[0]
		
res = func(1,5,9.1,"你好",[1,19,100],(99,-7),{"a":1000,"b":3,"c":"abc"},{98,-10})
print(res)



# 5.定义函数:传入一个参数n，返回n的阶乘(5! = 5*4*3*2*1)
def func(n):
	total = 1
	for i in range(n,0,-1):
		total *= i
	return total
res = func(6)
print(res)

# 6.写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),
	# 将容器中的每个元素依次添加到新的列表中返回
	#例:传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
# 方法一
def func(*args):
	lst = []
	print(args)
	for i in args:
		for j in i:
			lst.append(j)
			
	return lst
	
res = func([1,2,3],(22,33))
print(res)

# 方法二
def func(*args):
	# print(args)
	return list(args)
func(*[1,2,3],*(22,33))



# 7.写函数，用户传入要修改的文件名，与要修改的内容，执行函数，修改操作
def func(file,str1,str2):
	# 打开文件读取所有内容
	with open(file,mode="r+",encoding="utf-8") as fp:
		strvar = fp.read()
	print(strvar)
	# 替换字符串
	strvar = strvar.replace(str1,str2)
	# 重写写入
	with open(file,mode="w+",encoding="utf-8") as fp:
		fp.write(strvar)

func("ceshi.txt","好的","坏的")


def func(file,str1,str2):
	with open(file,mode="r+",encoding="utf-8") as fp:
		strvar = fp.read()
		strvar = strvar.replace(str1,str2)
		# 把光标移动到开头
		fp.seek(0)
		# 没有参数等于没有截取,相当于清空
		fp.truncate()
		fp.write(strvar)
func("ceshi.txt","坏的","好的")


# 8.写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
def func(strvar):
	# dic = {"num":0,"word":0,"space":0,"other":0}
	dic = {}.fromkeys(["num","word","space","other"] ,0  )
	print(dic)
	for i in strvar:
		if i in "0123456789":
			dic["num"] += 1
		elif i.lower() in "abcdefghijklmnopqrstuvwxyz":
			dic["word"] += 1
		elif i == " ":
			dic["space"] += 1
		else:
			dic["other"] += 1
			
	return dic
		
	
strvar = "234JKJK^&* "
res = func(strvar)
print(res)


def func(strvar):
	# dic = {"num":0,"word":0,"space":0,"other":0}
	dic = {}.fromkeys(["num","word","space","other"] ,0  )
	for i in strvar:
		if i.isdecimal():
			dic["num"] += 1
		# elif i.isalpha(): isalpha 可以在字节流模式下,分辨出中文(False)和字母(True)
		elif i.encode().isalpha():
			dic["word"] += 1
		elif i.isspace():
			dic["space"] += 1
		else:
			dic["other"] += 1
			
	return dic
strvar = "234JKJK^&* 你好"
res = func(strvar)
print(res)



# 9.写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，返回处理后的结果.
	#例:参数为:dic = {"k1": "v1v1", "k2": [11,22,33,44]}

def func(dic):
	for k,v in dic.items():
		# print(k,v)
		if isinstance(v,(str,list,tuple)) and  len(v) > 2:
			dic[k] = v[:2]
	return dic
dic = {"k1": "v1v1", "k2": [11,22,33,44],"k3":123}
res = func(dic)
print(res)

# 10.传入多个一级容器类型数据,计算元素总个数
def func(*args):
	total = 0
	for i in args:
		total += len(i)
	return total
	
res = func([1,2,3],(3,4),{6,7,8},{"a":1,"b":2})
print(res)