版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/plychoz/article/details/86515911
返回函数、高阶函数、匿名函数、偏函数、list.sort()中key的使用方法、列表生成式、引用、浅拷贝和深拷贝、闭包、拆包
import copy
#返回函数
def show():
def inner():
print('abc')
return inner
result = show()
print(result)
#return inner处加括号，inner调用，打印出abc，但是show函数没有返回值
def show():
def inner():
print('abc')
return inner()
result = show()
print(result)
#高阶函数
#返回函数是一种高阶函数
#函数作为参数
def sum_num(num1, num2):
result = num1+num2
return result
def func(num1, num2, nuw_func):
value = nuw_func(num1,num2)
print(value)
func(1,2,sum_num)
#匿名函数
#使用lanbda关键字，简化代码
#返回值不需要加return
def func(a,b,c):
return a+b+c
result = lambda a,b,c: a+b+c #匿名函数
print(result(1,2,3))
result1 = lambda num: num%2 == 0
resutt2 = lambda num: True if num%2 == 0 else False
num = 4
if result1(4):
print('%d是偶数' % num)
#偏函数：函数的参数偏爱某个值
def show(num1, num2, num3 = 3):
result = num1+num2+num3
print(result)
# show(1,2)
# 定义一个偏函数，在不改变原函数的情况下，添加新功能
def show2(num1, num2, num3 = 4):
result = show(num1,num2,num3)
print(result)
show2(1,2)
# 偏函数简写方式
import functools
# newfunc = functools.partial(show2, num2 = 1)
# newfunc(1)
result = int("123")
print(result)
newfunc = functools.partial(int,base = 2)
result = newfunc('1010')
print(result)
#sort()和sorted()
#sort()是列表的内置函数，sorted()是python的内置函数
#list.sort()是对原列表进行操作，sorted(list)返回一个新列表
my_list = [{'name': 'wang', 'age': 18}, {'name': 'li', 'age': 23, 'sex': 'man'}]
#使用匿名函数对字典排序，匿名函数是一个没有函数名的函数
my_list.sort(key=lambda item: item['age'], reverse=True) #item是列表中的每一项元素
print(my_list)
#等价于
def func(item):
return item['age']
my_list.sort(key=func, reverse=False)
print(my_list)
#列表生成式(推导式) 简化代码
my_list1 = [x*2 for x in range(5)]
print(my_list1)
result = [[x, y] for x in range(1, 5) for y in range(1, 3)] #双层for循环
print(result)
my_list2 = [x for x in range(5) if x % 2 == 0]
print(my_list2)
#引用，数据在内存中的地址
a = 'abc' #a存储的是abc在内存中的地址
b = a
print(id(a)) #变量a存储的地址
print(hex(id(a)))
print(hex(id(b)))
#可变类型和不可变类型
#可变类型：可以在原数据的基础上进行修改，并且其内存地址不变，列表、字典、集合
#不可变类型：字符串、数字、元组
list1 = [1,2,3]
print(list1, id(list1))
list1 = [1,3,4] #完全改变，不同于修改列表中的元素
print(list1, id(list1))
#深拷贝和浅拷贝
#浅拷贝：内存地址指向同一个地址
#深拷贝：都有自己独立的内存地址
#赋值操作，默认传递对象的引用 (比较浅的拷贝)
alist = [1,2,3]
blist = alist
print(id(alist))
print(id(blist))
alist.append(4)
print(alist, blist)
#copy，python中的浅拷贝,只拷贝一层
#需要导入模块copy
#浅拷贝只拷贝一层，其余层不变；如果只有一层，就相当于深拷贝
alist = [1,2,3,['a', 'b']]
clist = copy.copy(alist)
print(alist, id(alist))
print(clist, id(clist))
alist.append(4)
print(alist, id(alist))
print(clist, id(clist))
alist[3].append('c')
print(alist, id(alist))
print(clist, id(clist))
#结果
# [1, 2, 3, ['a', 'b']] 42616136
# [1, 2, 3, ['a', 'b']] 42925832
# [1, 2, 3, ['a', 'b'], 4] 42616136
# [1, 2, 3, ['a', 'b']] 42925832
# [1, 2, 3, ['a', 'b', 'c'], 4] 42616136
# [1, 2, 3, ['a', 'b', 'c']] 42925832
#总结：只拷贝一层，其余层不变，如果只有一层，相当于深拷贝
#深拷贝
alist = [1,2,3,['a','b']]
blist = copy.deepcopy(alist)
alist.append('c')
print(alist, id(alist))
print(blist,id(blist))
#总结：深拷贝就是克隆了一份，每一份都有自己独立的内存，两者互不相关
#闭包:在函数嵌套的情况下，内部函数使用了外部函数的参数或者变量，并且把这个内部函数返回，这个内部函数可以成为闭包
#闭包形成的条件：1、有内嵌函数；2、内部函数使用外部函数的变量或者参数；3、外部函数返回内嵌函数
#可以提高代码的复用性
def show():
num = 10
def inner():
print(num)
return inner
#计算直线上的点
#使用默认参数实现
def show(x,a=2,b=5):
return a*x+b
show(3)
#使用闭包实现
def func(a,b):
def show(x):
return a*x+b
return show
new_func = func(2,5)
new_func(3)
#对局部变量的一个保存，缺点：消耗内存
def fn():
n = 100 #局部变量
def inner():
#n+=1 #报错
nonlocal n #可以调用上一层的作用域作用的变量
n+=1
print(n)
return inner
t = fn()
t() #101
t() #102
#因为局部变量n被inner函数引用了，而t=inner，t是全局变量
del t #清空内存
#拆包
# *和**除了拆包，没有其他作用
my_list = [1,2,3]
print(*my_list)
my_tuple = (1,2,3)
print(my_tuple)
def func(*args, **kwargs):
print(*args)
print(args)
func(1,2,3, a=10) #将1,2,3打包成一个元组(1,2,3)传过去
func([1,2,3])