函数方法和模块

函数方法：

函数使用方法：

​ 匿名函数：一句话函数，用于内置函数，匿名函数结合内置函数使用

​ func = lambda x,y : x+y 名字func :前形参 :后返回值

​ 示例1：

​ func = lambda x : (x[0],x[2]) 返回多个元素加（）

​ 示例2：

​ func = lambda x,y :x if x > y else y

​ func = lambda *args : max(args) #返回最大的值，也能够添加三元运算>

​ 内置函数：***加key的 min，max，sorted，map，reduce，filter

​ 加key的格式：

​ 将最小的值返回

​ dic = {'a':3,'b':2,'c':1}

​ print(min(dic.values(),key=lambda x:x)) key=lambda 函数名 :前形参 :后返回值

callable：

• 检查一个对象是否能够调用

  def haiyang():
      pass
  haiyang()
  
  print(callable(haiyang))

abs：

• 返回数字的绝对值

  l = -8
  print(abs(l))

sum：

• 数字相加求和

  print(sum([1,2,3,4,5]))   #sum函数内，存放的是可迭代函数
  print(sum([1,2,3,4,5],10))

min：

• min求最小值

• max求最大值

  # 将成绩最低的从属于的那个列表返回。
  # 将成绩最低的分数返回。
  dic = {'a':['李业',67],'b':['怼哥', 95],'c':['方垚', 55]}
  
  print(dic[min(dic,key=lambda x:dic[x][1])])   #min取出来的key为c,经过字典c key键找到列表
  
  print(dic[min(dic,key=lambda x:dic[x][1])][1])   #找到列表在经过[1]找到55

reversed：

• 将一个可迭代对象进行翻转，返回的是一个迭代器

  l = reversed('胡海洋')
  print(list(l))  #翻转获取到的是一个生成器，须要经过list进行打印
  
  l1 = reversed([1,2,3,4,5,6])
  print(list(l1))     #翻转列表

bytes：

• 将字符串转换成bytes类型

  l = "胡海洋"
  
  l1 = l.encode('utf-8')   #encode转换成bytes字节
  print(l1)
  
  l2 = bytes(l,encoding='utf-8')
  print(l2)

zip拉链方法：

• 将可迭代对象做为参数，将对象中对应的元素，打包成一个个元祖，若是变量的元素不一直，按最短的取

  l1 = [1,2,3,4]
  l2 = ['a','b','c','d','e']
  
  for i in zip(l1,l2):  #
      print(i)

sorted:

• 排序函数

  语法：sorted（iterable，key=None，reverse=False）

  iterable 可迭代对象

  key 排序规则，sorted内部会将可迭代对象中每个元素，传递给函数形参，进行排序

  reverse True 倒序 Flase正序

  列表排序：

  l = [1,3,4,7,8,2]
  l1 = sorted(l)    #默认正序
  print(l1)
  
  l2= sorted(l,reverse=True)  #为True倒序
  print(l2)

  字典排序：

  dic  = {1:'a',3:'c',2:'b'}
  dic1 = sorted(dic)   # dic1键值排序为1,2,3
  
  dic2 = {}
  for i in dic1:      #建立新的字典，for循环排序好key,添加到新字典
      dic2[i] = dic[i]
  print(dic2)

  结合函数使用：

  # 按照列表内的字符串长度排序
  l1 = ['天龙八部','西游记','红楼梦','三国演义']
  
  print(sorted(l1,key=lambda x:len(x)))

  #根据年龄进行排序
  l1 = [{'id':1,'name':'胡海洋','age':18},
      {'id':2,'name':'俊丽','age':17},
      {'id':3,'name':'宝宝','age':1},]
  
  print(sorted(l1,key=lambda x:x['age']))  #x['age] 先找到年龄key在进行排序

filter:

• 筛选过滤

  语法：filter（function，iterable）

  iterable 可迭代对象

  function 用来筛选函数，在filter中会自动把迭代对象中的元素传递给function，以后根据function返回 True或者Flase来判断是否保留此项数据

  字典筛选年龄大于十六的

  l1 = [{'id':1,'name':'alex','age':18},
          {'id':1,'name':'wusir','age':17},
          {'id':1,'name':'taibai','age':16},]
  
  l2 = filter(lambda x:x['age'] > 16,l1) 
  print(list(l2))
  #变成迭代器一一进行判断，lamdba函数，x形参，x['age]返回值判断，l1可迭代对象

  ​

map：

• 映射函数

  语法：map(function,iterable)

  能够对可迭代对象中的每个元素进行映射，分别取值执行function

  计算列表中每一个元素的平方,返回新列表

  lst = [1,2,3,4,5]
  # def func(s):
  #     return  s*s
  #
  # mp = map(func,lst)
  # print(mp)
  # print(list(mp))
  
  # 改写成lamdba
  print(list(map(lambda x:x*x,lst)))

  计算两个列表中相同位置的数据的和

  lst1 = [1, 2, 3, 4, 5]
  lst2 = [2, 4, 6, 8, 10]
  
  print(list(map(lambda x,y:x+y,lst1,lst2))) #传入多个值进行计算

reduce:

• 使用方法：

  reduce（函数名，可迭代对象）

  做用：

  ​ 先把列表中的前两个元素取出来，计算出结果进行保存，当进行到第二个元素传参时，将第一次计算完的 结果与10相乘计算，求出一个新的值将最开始临时保存的值替换掉，依次类推

  from functools import reduce
  
  def func(x,y):
      return x * 10 + y
      # 第一次的时候 x是1 y是2  x乘以10就是10,而后加上y也就是2最终结果是12而后临时存储起来了
      # 第二次的时候x是临时存储的值12 x乘以10就是 120 而后加上y也就是3最终结果是123临时存储起来了
      # 第三次的时候x是临时存储的值123 x乘以10就是 1230 而后加上y也就是4最终结果是1234而后返回了
  
  l = reduce(func,[1,2,3,4])
  print(l)
  
  
  #lamdba方法：
  from functools import reduce
  
  l = reduce(lambda x,y:x * 10 + y,[1,2,3,4])
  print(l)