1. 什么是匿名函数
匿名函数还是函数，只是声明的格式和普通函数不一样。只适用于函数功能比较简单的函数
2. 匿名函数的声明
a. 语法
变量名 = lambda 形参列表：返回值
b. 说明
变量名 - 相当于函数名
lambda - 声明匿名函数的关键字
形参列表 - 和普通函数的形参列表是一样的
： - 固定写法
返回值 - 就相当于普通函数中只有一条return语句的函数体
3. 匿名函数的调用
和普通函数一样
a. 匿名函数的参数也可以设置默认值（不会有类型提示）
b. 匿名函数不能通过添加：类型名来说明参数类型
func1 = lambda x, y=0: x+y
这个函数和上面的匿名函数一模一样！
def func1(x,y):
return x+y
print(func1(10,20))
c. 匿名函数可以设置不定长参数
func2 = lambda *nums:sum(nums)
print(func2(1,2,3,4,5))
func3 = lambda x:print(x)
print(func3(100)) # None
4. 什么是变量的作用域
就是变量能够使用的范围
5. 全局变量和局部变量
a. 全局变量 - 没有声明在函数或者类中的变量都是全局变量
全局变量的作用域：从声明开始到整个文件结束
b. 局部变量 - 声明在函数或者类中的变量都是局部变量
局部变量的作用域：从声明开始到函数结束
总结：当我们调用函数的时候，系统会自动在栈区间开辟一块独立的内存空间，用来保存在函数中声明的变量（形参也是属于声明在函数中的变量）。当函数调用结束后，这个栈区间会自动销毁。——（函数的调用过程是一个压栈的过程）
- 全局变量
变量a是全局变量
a = 100
print(a)
for x in range(a):
print('循环里：',a)
def func1():
print('函数中：',a)
func1()
- 全局变量
这儿的y也是全局变量
for y in range(3):
print(y)
print('外面：',y)
def func2():
print('函数里：',y)
func2()
- 局部变量
a. 函数的形参就相当于声明在函数中的变量，所以是局部变量
num1 是局部
def func(num1):
print(num1)
print(num1) 局部变量不能在函数外使用
函数中的nums,max1和item都是局部变量
def func4(*nums):
# nums=(1,89,9,887,0)
max1 = nums[0]
for item in nums:
if item > max1:
max1 = item
print()
func4(1, 89, 9, 887, 0)
# print(item)
- 如果全局变量和局部变量同名，那么在局部变量的作用域中使用的是局部变量，外部使用的是全局变量
aa = 100
def func5():
# 局部变量aa
aa = 200
print('函数里', aa)
func5()
print('外部：', aa)
6. global - 在函数中声明一个全局变量
在函数中：
global 变量名
变量名 = 值
bb = 111
def func6():
global bb
bb = 222
print('函数里：', bb)
func7()
print(bb)
7. nonlocal - 想要在局部的局部中去修改局部变量的值，就使用nonlocal对变量进行说明
def func11():
abc = 123
print('func11',abc)
def func22():
nonlocal abc
abc = 333
print('func22',abc)
func22()
func11()
list1 = []
for i in range(5):
list1.append(lambda x: x*i)
# list1 = [lambda x: x*2]
# print(list1[0]())
python中声明函数其实就是声明一个类似就是function的变量，函数名就是变量名
函数名 —— 类型是function的变量
函数名（） —— 调用函数并且获取函数的返回值
普通变量能做的事情函数变量都能做！
- 给别的变量赋值
# 声明了一个列表变量list1
list1 = [1,2,3]
# 声明一个函数变量
def func1():
return 10
# 使用列表变量给另外一个变量list2赋值
list2 = list1
# 赋值list2就可以当成列表来用
print(list2[0])
print(list2[::-1])
list2.append(100)
print(list2)
# 使用函数变量给另外一个变量func2赋值
func2= func1
# 赋值后func2就可以当成函数来使用
func2()
print(func2())
- 变量作为容器类数据的元素
a = 10
nums = [a, 100, 1000]
print(nums)
print(nums[0]-10)
def func3():
print('abc')
return 10
list2 = [func3, func3(), 100]
#print(list2)
#print(list2[0](1))
- 变量作为函数的实参
函数1是函数2的实参—— 函数2就是一个高阶函数
a = 10
def func4(n:int):
print(n + n - 1)
def func5(x):
print(x)
func5(func4(2))
func5(lambda x:x*2)
函数作为参数的应用：sort函数
列表.sort(key=None,reverse=False)
参数key-要求是一个带有一个参数，并且返回值是布尔的函数。这儿的参数指向是列表中的元素。确定
list1 = [1, 23, 9, 90]
list1.sort(reverse=True)
print(list1)
all_student = [
{'name': '张三', 'age': 19, 'score': {'语文': 90, '数学': 80, '英语': 70}},
{'name': '李四', 'age': 18, 'score': {'语文': 94, '数学': 76, '英语': 80}},
{'name': '王五', 'age': 20, 'score': {'语文': 88, '数学': 85, '英语': 70}},
{'name': '赵六', 'age': 25 ,'score': {'语文': 60, '数学': 50, '英语': 40}}
]
这儿的item是需要排序的列表的元素
def func(item):
return item['score']
all_student.sort(key=lambda item: item['score'], reverse=True)
print(all_student)
练习：按学生平均分排序
all_student = [
{'name': '张三', 'age': 19, 'score': {'语文': 90, '数学': 80, '英语': 70}},
{'name': '李四', 'age': 18, 'score': {'语文': 94, '数学': 76, '英语': 80}},
{'name': '王五', 'age': 20, 'score': {'语文': 88, '数学': 85, '英语': 70}},
{'name': '赵六', 'age': 25 ,'score': {'语文': 60, '数学': 50, '英语': 40}}
]
all_student.sort(key=lambda item: sum(item['score'].values())/3)
print(all_student)
tuple1 = (
(10, 20),
(5, 80),
(30, 90)
)
new_tuple = sorted(tuple1, key=lambda item: sum(item))
print(new_tuple)
print('=============')
练习: 按学生的平均分排序
all_student = [
{'name': '张三', 'age': 19, 'score': {'c': 78, 'm': 90, 'e': 40}},
{'name': 'stu1', 'age': 30, 'score': {'c': 89, 'm': 60, 'e': 98}},
{'name': 'xiaoming', 'age': 12, 'score': {'c': 78, 'm': 67, 'e': 86}},
{'name': 'stu22', 'age': 29, 'score': {'c': 34, 'm': 99, 'e': 50}}
]
def average(student):
scores = student['score']
sum1 = 0
for key in scores:
sum1 += scores[key]
return sum1/3
all_student.sort(key=average)
print('~~~~~~~~~~~')
print(all_student)
# =============排序原理(了解)=============
def yt_sorted(iterable, key=None, reverse=False):
list1 = list(iterable)
if key:
for x in range(len(iterable) - 1):
for y in range(x + 1, len(iterable)):
item1 = list1[x]
item2 = list1[y]
if key(item1) > key(item2):
list1[x], list1[y] = list1[y], list1[x]
else:
# 快速排序
for x in range(len(iterable) - 1):
for y in range(x + 1, len(iterable)):
if list1[y] < list1[x]:
list1[x], list1[y] = list1[y], list1[x]
if not reverse:
# 从小到大
return list1
else:
# 从大到小
return list1[::-1]
print(yt_sorted([1, 20, 9, 10]))
# print(sorted(all_student, key=lambda x: x['age']))
print(yt_sorted(all_student, key=lambda x: x['age'], reverse=True))
4.变量作为函数的返回值
函数1作为函数2的返回值 - 函数2是返回值高阶函数
def operation(char):
# char = '-'
if char == '+':
def func1(*nums):
return sum(nums)
# 将函数作为函数的返回值
return func1
elif char == '-':
def func2(*nums):
# (10, 3, 4)
# 如果没有传参
if not nums:
return 0
sum1 = nums[0]
for index in range(1, len(nums)):
sum1 -= nums[index]
return sum1
return func2
print(operation('+')(1, 2, 3, 4))
print(operation('-')(10, 3, 4))
网友评论