2022.10.10 周一

2022.10.10 周一

1.匿名函数 ——本质还是函数（除了定义函数的语法以外的函数相关内容都适用于匿名函数）

语法：

函数名 = lambda 形参列表 ：返回值

相当于：

def 函数名(形参列表):

​ return 返回值

# 写一个匿名函数求任意两个数的和
sum2 = lambda num1,num2 : num1 + num2
print(sum2(10,20))
# 写一个匿名函数求任意三个整数的个位数的和
sum2 = lambda num1,num2,num3 : num1 % 10 + num2 % 10 + num3 % 10

2.高阶函数 ——分为实参高阶函数和返回值高阶函数两种

函数的参数的确定方式

# x可以任何数据
def func(x):
    print(x)
# x可以传整数、浮点数、布尔、列表、字符串、元组
def func2(x)
	print(x * 2)
# x可以传列表、字符串、元组、字典
def func3(x)
	print(x[1])
# x只能传列表
def func4(x)
	print(x.append(100))
# func5和func6是实参高阶函数
# x必须是不需要传参数就可以调用的函数
def func5(x)
	print(x())    # print(t1())
def t1():
    print('abc')
func5(t1)
# x必须是一个可以接收两个实参的函数，并且函数的返回值是数字
def func6(x):
    print(x(10,20) + 30)
# func7是一个返回值高阶函数
def func7():
    def func8();
    	print('abc')
    return fuunc8

• 实参高阶函数——参数是函数的函数

  注意

  函数的参数如果是函数，提供实参方式有两种：1.直接使用匿名函数

  ​ 2.使用普通函数的函数名

  常见的实参高阶函数

  • max、min、sorted(sort)

    max(序列，key=函数) ——根据函数自定的比较规则比较序列中元素的大小获取最大值

    函数要求：

    ​ 1.有且只有一个参数（代表序列中的每个元素）

    ​ 2.需要一个返回值（代表比较对象 ——将参数看成序列中的元素，返回值对应的位置描述清楚比较对象和元素之间的关系）

  # 求nums中个位数最大的元素
  nums = [19,23,90,34,56,78]
  print(max(nums))
  print(max(nums,key = lambda items : items % 10))
  # 求nums中绝对值最大的元素
  nums = [19,23,-90,34,-56,78]
  print(max(nums,key = lambda items : items ** 2))
  
  students = [
      {'name':'小明', 'age':19,'score':73},
      {'name':'小红', 'age':22,'score':99},
      {'name':'小花', 'age':32,'score':80},
      {'name':'张三', 'age':20,'score':77},
  ]
  # 求students中分数最高的学生
  print(max(students, key = lambda items : items['score']))
  # 按照年龄的大小对students中元素从小到大排序
  print(sorted(students, key = lambda items : items['age']))
  # 将names中所有的元素按照每个名字的长度从大到小排序
  names = ['路飞', '乌索布', '索罗', '鲁班7号', '烬']
  print(sorted(names, key=lambda items: len(items), reverse=True))
  # 7）求nums中各个位数之和最大的元素
  nums = [123, 98, 562, 90, 990, 1000]
  # 方法1
  print(max(nums, key=lambda items: sum(int(x) for x in str(item))))
  # 方法2 
  def temp(items):
      s = 0
      for x in str(items):
          s += int(x)
      return s
  print(max(nums,key=temp))
  

  • map ——基于原序列中的元素通过指定的规则创建一个新的序列

    map(函数，序列)

    函数的要求：有且只有一个参数（代表序列中的每个元素）

    ​ 有一个返回值（就是新序列中的元素——在这儿通过参数来描述新序列中的元素和原序列中元素的关系）

    map(函数，序列1，序列2，序列3，……序列N)

    函数的要求：有且只有N个参数（分别代表后面N个序列中的每个元素）

    ​ 有N个返回值（就是新序列中的元素——在这儿通过参数来描述新序列中的元素和原序列中元素的关系）

    # 将nums中所有的元素乘以2
    nums = [2, 11, 33, 40, 9]
    result = map(lambda item: item * 2, nums)
    print(list(result))
    # 求score1和score2的元素相加
    score1 = [98,78,80]
    score2 = [99,90,60]
    result = map(lambda item1,item2: item1 + item2 ,score1,score2)
    print(list(result))
    

  • reduce ——将序列中所有的元素合并成一个数据

    reduce(函数，序列，初始值)——将序列中的元素按照函数制定的规则合并成一个数据

    函数的要求：有且只有两个参数（第一个参数指向初始值，第二个参数代表序列中的每个元素）

    ​ 有一个返回值（用来描述合并规则）

    # 求nums中所有元素的和
    from functools import reduce
    nums = [12,30,89,76,55]
    result = reduce(lambda i, item: i + item, nums, 0)
    print(result)
    # 求nums中所有元素的乘积
    nums = [12,30,89,76,55]
    result = reduce(lambda i, item: i * item, nums, 1)
    print(result)
    # 求nums中所有元素的个位数的和
    nums = [12,30,89,76,55]
    result = reduce(lambda i, item: i + item % 10, nums, 0)
    print(result)
    # 将nums中所有元素合并成一个数字
    nums = [12,30,89,76,55]
    result = reduce(lambda i, item: i + str(item), nums, '')
    print(int(result))
    # 将ist1中所有字符串的最后一个字符合并成一个新中字符串
    list1 = ['anm', 'abc', 'hello', 'world']
    # 'mcod'
    result = reduce(lambda i, item: i + item[-1], list1, '')
    print(result)
    

• 返回值高阶函数——返回值是函数的函数

3.迭代器（iter）

容器型数据类型：迭代器作为容器，打印的时候无法显示所有元素，无法通过len获取迭代器中元素的个数

​ 如果要使用迭代器中元素必须将元素从迭代器中取出来，而且一旦取出无法再放回去

3.1怎么创建迭代器

• 将其他序列转换成迭代器

i1 = iter('abc')
i2 = iter([10,20,30,40])
print(i1)  # 看不到数据
print(i2)  # 看不到数据

• 创建生成器

3.2 怎么获取迭代器中的元素

不管以什么方式获取到了迭代器中的元素，对应的元素一定会从迭代器中消失

• 查单个：next(迭代器)

• 遍历

  i1 = iter('abc')
  i2 = iter([10,20,30,40])
  print(next(i1))  # a
  print(next(i1))  # b
  print(next(i1))  # c
  print(next(i1))  # 报错：StopIteration （迭代器已经空了）
  for x in i2	
  	print(x)
  i3 = iter('hello')
  print(list(i3))  # [h,e,l,l,o]
  print(next(i3)  # 报错：i3转换成列表已经把所有元素取走了
  

4.生成器

容器型数据类型：生成器作为容器不具备同时保存多个数据的能力，具备的是创建多个数据的能力

打印生成器也无法查看生成器中的元素，生成器无法统计个数

获取生成器中的元素，也是取一个少一个（生成器获取元素的方法和迭代器是一样的）

4.1怎么创建生成器

调用带有yield关键字的函数就可以得到一个生成器

def func1():
    print('abc')
    yield
    return 100
result = func1()
print(result)   
# abc
# 100

4.2生成器的元素——控制元素的个数个元素的值

执行创建生成器的函数的函数体会遇到几次yield，对应的生成器就可以创建多少个数据

每次遇到yield的时候，yield后面的数据就是这个生成器能够创建的值

def func2():
    for x in range(5):
		yield x * 2
g2 = func2()
print('===', x)
# === 0
# === 2
# === 4
# === 6
# === 8