Python基础4: 函数

返回函数、高阶函数、匿名函数、偏函数、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])