1. 匿名函数
1.1 什么是匿名函数
没有函数名的函数就是匿名函数 （匿名函数还是函数！！！！！！）
1.2 语法
lambda 形参列表: 返回值
说明:
- lambda - 关键字，固定写法
- 形参列表 - 和普通函数的形参列表一样的。变量名1,变量名2..
(参数相关的语法中，除了':类型名'对参数类型进行说明以外，别的语法都适用) - : - 固定写法
- 返回值 - 相当于普通函数中return后面的语句
注意: 匿名函数能做的事情普通函数都可以做；但是多行代码的普通函数，匿名函数没法实现
def yt_sum(n1: int, n2):
if n1 < 10:
print('n1')
return n1+n2
lambda n1, n2: n1+n2
1.3 调用 （和普通函数一样）
- 函数(实参列表) --- 函数不一定是函数名，可以是通过任何方式获取到的类型function的值
- python中，声明函数其实可以看成是声明类型是function的变量；匿名函数可以看成是function类型的数据（类似100是int类型的数据）
- 变量名 = lambda 参数列表: 返回值 --- 通过'变量名()'来调用匿名函数
a = 100
b = 12.5
c = 'abc' # 类型是str的值
d = [10, 23, 90, 'abc'] # 类型是list的值
e = {'a': 100, 'b': 200} # 类型是dict的值
print(type(e))
print(e['a'])
f = lambda x, y: x*y # 类型是function的值 return x*y
print(type(f))
print(f(10, 20))
print(f(y=30, x=2))
list1 = [100, b, c, d, e, lambda x, y:x+y]
print(list1[0]+200)
print(list1[-1](10, 22))
2. 高级函数
2.1 函数作为变量（重点！！！）
- python中声明函数其实就是在声明一个类型是function的变量，函数名就是变量名。所以普通变量能做的事情，函数都能做
- 声明一个函数func1,有一个参数一个返回值；
- func1是类型是function的变量，它里面存的数据是一个函数，函数名叫func1,有一个参数n
a = 100
# func1 = lambda n:n*n
def func1(n):
return n*n
print(a, type(a), a//2)
print(func1, type(func1), func1(10))
2.2 普通变量能做的函数都能做
2.2.1. 用一个变量给另外一个变量赋值
print('==========用一个变量给另外一个变量赋值============')
list1 = [1, 2]
list2 = list1
print(list2[0])
def fun2(n):
# n = 22
return n*3 # return 22*3
a1 = fun2
print(a1(22))
"""
fun2 = function(), 有一个参数n
"""
2.2.2 变量可以作为列表/元祖的元素、作为字典的值等
list1 = [1, 2]
dict1 = {'a': list1}
def fun3(n):
return n*2
dict1 = {'a': list1, 'b': fun3}
dict1['a'].append(100)
print(dict1)
print(dict1['b'](9)) # fun3(9)
2.2.3 变量作为函数的实参
将函数作为实参传递给另外一个函数（实参高阶函数、闭包）
nums = [1, 2, 3]
print(sum(nums))
def fun4(a):
# a = print
a('abc') # print('abc')
print(fun4(print))
2.3 应用: sort方法的高级使用
列表.sort(key) - key需要传一个类型是function的值(函数)，要求这个函数有一个参数和一个返回值，参数指向的是列表中的每个元素，返回值是排序的时候的比较对象
def yt_sort(list1, key=None, reverse=False):
length = len(list1)
if reverse:
# 降序排列
for x in range(0, length-1):
for y in range(x+1, length):
if key:
if key(list1[y]) > key(list1[x]):
list1[x], list1[y] = list1[y], list1[x]
else:
if list1[y] > list1[x]:
list1[x], list1[y] = list1[y], list1[x]
else:
for x in range(0, length-1):
for y in range(x+1, length):
if key:
if key(list1[y]) < key(list1[x]):
list1[x], list1[y] = list1[y], list1[x]
else:
if list1[y] < list1[x]:
list1[x], list1[y] = list1[y], list1[x]
nums = ['1', '60', '27', '9']
yt_sort(nums, key=lambda x: x[-1])
print(nums)
nums = [1, 90, 89, 9]
yt_sort(nums, reverse=True)
print(nums)
max(['23', '9', '100', '8923'])
# yt_max(['23', '9', '100', '8923'])
# yt_max(['23', '9', '100', '8923'], key=lambda x: int(x))
2.4 尝试: 实现自己的max函数
def yt_max(seq, key=None):
list1 = list(seq)
max1 = list1[0]
for index in range(1, len(list1)):
item = list1[index]
if key:
if key(item) > key(max1):
max1 = item
else:
if item > max1:
max1 = item
return max1
print(yt_max({'1': 78, '9': 20, 'a': 100}))
print(max({'1': 78, '9': 20, 'a': 100}))
print(max(['23', '9', '100', '8923'], key=lambda x: int(x)))
print(yt_max(['23', '9', '100', '8923'], key=lambda x: int(x)))
2.5 变量作为函数的返回值
python中函数中可以再声明函数
def yt_sum(n1: int, n2: int):
sum1 = n1+n2
return sum1
result = (yt_sum(10, 78) + 100) *2
print(result)
def operation(char):
# char = '+'
if char == '+':
# sum1函数
def sum1(*nums):
# nums = 1,2,4,5,6
x = 0
for item in nums:
x += item
return x
return sum1
elif char == '-':
def sub(*nums):
x = nums[0]
for index in range(1, len(nums)):
x -= nums[index]
return x
return sub
return None
result1 = operation('+')(1, 2, 4, 5, 6) # sum1(1,2,4,5,6) 18
result2 = operation('-')(10, 4, 1)
print(result1, result2)
读程序
list3 = []
for i in range(5):
# list3.append(lambda x: x*i)
def fn(x):
return x*i
list3.append(fn)
list3 = []
i = 0 list3 = [lambda x: x*i]
i = 1 list3 = [lambda x: x*i, ambda x: x*i]
i = 4 list3 = [lambda x: x*i, lambda x: x*i,lambda x: x*i,lambda x: x*i,lambda x: x*i]
list3[3](3) # 12
list3[0](3) # 12
list3[2](3) # 12
3. 变量作用域
1.作用域： 变量的使用范围
2.全局变量和局部变量
- 全局变量: python中除了在函数中或者类中声明的变量，都是全局变量。
全局变量的作用域:从声明开始到文件结束的任何位置都可以使用 - 局部变量: 在函数中声明的变量就是局部变量。
从声明开始到函数结束都可以使用
3. 2.1 全局变量
#这个变量a是全局变量
a = 10
print(a)
#这个变量i也是全局变量
for i in range(3):
# 变量y是全局变量
y = 'abc'
print(a)
print(i, y)
def func1():
print(a, i, y)
func1()
3.2.2 局部变量
def func2(m1):
# 形参m1是局部变量
print(m1)
m2 = 200
print(m2)
func2(100)
# print(m1)
# print(m2)
3.3 global和nonlocal
global: 想要在一个函数中去修改一个全局变量的值，或者想要在函数中声明一个全局变量
global 变量名
变量名 = 值nonlocal: 想要在局部的局部中修改一个局部变量的值
nonlocal 变量名
变量名 = 值
aa = [12, 34]
def func11():
# 不能在函数中直接修改一个全局变量的值，而是重新声明一个新的局部变量
# aa = [100, 200]
global aa, bb
aa = 200
# global bb
bb = 'abc'
print(aa, bb)
func11()
print(aa)
print(bb)
def fun22():
aaa = 123
def fun222():
nonlocal aaa
aaa = 1000
print('==:', aaa)
fun222()
print(aaa)
fun22()
# print(aaa)
