python--函数进阶

1. 变量变量作用域

1. 根据变量作用域的不同，可以将变量分为全局变量和局部变量

2. 全局变量：Python中没有定义在函数内或者类中的变量默认都是全局变量。

   全局变量作用域从定义开始到程序结束

3. 局部变量：Python中定义在函数中的变量就是局部变量。

   局部变量作用域从定义开始到函数结束

4. 全局变量默认保存在全局栈区间，全局变了会在程序结束后自动释放

   调用函数时系统会自动为这个函数创建一个临时栈区间用来保存函数中产生的数据（局部变量）函数对应的临时栈区间会在这个函数调用结束的时候自动释放

5. 在函数中可以使用关键字global修改局部变量的保存方式

   # global 变量名 放在定义变量语句前
   def func(a):
       global b
       b = 20
   
   
   print(func(10))
   # 可以在全局使用变量b
   print(b)
   
   # 可以使用global关键字在函数内部修改全局变量的值
   name = 'xiaoming'
   
   
   def func(a):
       global name 	#不加global关键字+变量名的话就会另外创建一个局部变量值是小花
       name = 'xiaohua'
   
   
   func(3)
   print(name)
   

2.匿名函数lambda

1. lambda函数也叫匿名函数，即，函数没有具体的名称。

   # 函数名 = lambda 形参列表：返回值
   # 正常函数
   def f(x):
     	return x**2
   print f(4)
   # 匿名函数
   g = lambda x : x**2
   print g(4)
   

2. 参数用法和正常函数一样，但是不能定义形参数据类型（但是可以通过定义默认值的方法进行类型说明）

3.实参高阶函数

1. 函数的参数是函数的函数就是实参高阶函数

2. max() min() sorted() 列表.sort

   num_list = [1, 23, 34, 45, -4600, 52, 52, 127, 536]
   
   # 按个位数大小取最大值
   print(max(num_list, key=lambda num: num % 10))
   # 按绝对值大小取最大值
   print(max(num_list, key=lambda num: num **2))
   
   # 练习1：求list1中长度最长的字符串
   list1 = ['你好', 'hello', 'how are you', 'thank you! and you？', '好好学习，天天向上']
   print(max(list1, key=lambda item: len(item)))
   # 练习2：求nums中十位数最小的元素
   nums = [92, 129, 37, 99, 150, 501]
   print(min(nums, key=lambda item: item // 10 % 10))
   # 求nums中各个位数之和最大的
   # 方法1
   print(max(nums, key=lambda item: sum([int(x) for x in str(item)])))
   # 方法2
   print(max(nums, key=lambda item: eval('+'.join(str(item)))))
   # 方法3
   def sum_num(item):
       sum1 = 0
       for x in str(item):
           sum1+=int(x)
       return sum1
   print(max(nums,key=sum_num))
   # 练习3：将所有的学生按照年龄值从小到大排序
   students = [
       {'name': 'stu1', 'age': 18, 'score': 90},
       {'name': 'stu2', 'age': 22, 'score': 98},
       {'name': 'stu3', 'age': 25, 'score': 78},
       {'name': 'stu4', 'age': 19, 'score': 81},
       {'name': 'stu5', 'age': 20, 'score': 92}
   ]
   print(sorted(students, key=lambda item: item['age']))
   
   

3. map 基于原序列中的元素创建一个新的序列,原序列可以是一个或者多个

   map(函数,序列)

   1. 函数要求：有且只有（序列个数）个参数（代表后面的这个序列中的每个元素）
   2. 有一个返回值，返回值就是新序列中的元素(返回结果是一个迭代器)

   # map(函数,序列) 	函数有一个参数
   # map(函数,序列1,序列2)  函数有两个参数
   num1 = [1, 2, 3, 33, 23, 54]
   num2 = [1, 23, 67, 54, 345, 87]
   # num1中的每个元素都乘以10
   print(list(map(lambda x:x*10,num1)))
   # 结果为[10, 20, 30, 330, 230, 540]
   # num1 num2 中对应位置的元素相乘
   print(list(map(lambda x,y:x*y,num1,num2)))
   # 结果为[1, 46, 201, 1782, 7935, 4698]
   
   # 练习1：获取names中每个人的姓
   names = ['何晓东', '张三', '李四', '王五', '王二', '赵六']
   print(list(map(lambda name: name[0], names)))
   
   # 练习2：
   students = [
       {'name': 'stu1', 'age': 18, 'score': 90},
       {'name': 'stu2', 'age': 22, 'score': 98},
       {'name': 'stu3', 'age': 25, 'score': 78},
       {'name': 'stu4', 'age': 19, 'score': 81},
       {'name': 'stu5', 'age': 20, 'score': 92}
   ]
   subjects = ['电子信息', '金融数学', '园林设计', '经济', '计算机软件']
   
   # ['电子信息-stu1', '金融数学-stu2',....]
   print(list(map(lambda sub, stu: f'{sub}-{stu["name"]}', subjects, students)))
   

4. reduce 将序列中的元素合并成一个数据

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

   1. 函数的要求：
      1. 有且只有两个参数（第一个参数指向初始值，第二个参数代表序列中的每个元素
      2. 只需要一个返回值
   2. 初始值：
      1. 累计求数值和初始值为0
      2. 累计求数值乘积，初始值是1
      3. 字符串合并，初始值是空串

   # reduce(函数,序列,初始值) 按照函数指定的规则将序列中的元素合并成一个数据
   result1 = reduce(lambda x, item: x + item, nums, 0)
   print(result1)
   # 结果为520
   result2 = reduce(lambda x, item: x + item % 10, nums, 0)
   print(result2)
   # 结果为10
   result3 = reduce(lambda x, item: (x + str(item)), nums, '')
   print(result3)
   # 结果为123014055112
   

4. 迭代器iter

1. 概念

   1. 迭代器是容器型数据类型（可以遍历，也可以转换成列表）无法直接提供一个迭代器，只能将其他序列转换成迭代器。

   2. 特点：

      1. 打印迭代器时不能查看迭代器中的元素有哪些。

   3. 无法通过len获取迭代器中元素的个数

      1. 如果要使用迭代器中的元素必须将元素从迭代器中取出来，取出来的元素会在迭代器中永远消失

   4. 任何数据都可以作为迭代器中的元素

2. 操作迭代器

   1. 创建迭代器

      l1 = iter('abc')
      

   2. 打印迭代器无法查看元素

      print(iter('abc'))
      # 结果为
      

3. 操作迭代器中的元素

   1. 无论以任何方式获取迭代器中某个元素，那么这个元素一定会从迭代器中消失

   2. 获取单个元素

      next(迭代器) 获取迭代器最前面的元素,取走就会消失

      i3 = iter([1, 2, 3, 4, 5, 52, 1, 4, 1])
      print(next(i3))
      #	1
      print(next(i3))
      #	2
      print(next(i3))
      #	3
      print(list(i3))
      # [4, 5, 52, 1, 4, 1]
      print(next(i3))
      # 报错，因为上边已经变成空的迭代器了
      

   3. 遍历

      for 变量 in 迭代器：

      ​ 循环体

      遍历完后迭代器是空的

      for x in i3:
          print(x)
      

4. 洗牌