函数方法

函数方法：

目录

• 函数方法：
  • 函数使用方法：
  • 内置函数：
• 内置函数使用方法：
  • min：（大小）
  • sorted: （排序）
  • filter: （过滤）
  • map： （值叠加）
  • reduce:key
  • callable：
  • abs：（取绝对值）
  • sum：（求和）
  • reversed：（翻转）
  • bytes：
  • zip：（拉链方法）

函数使用方法：

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

​ 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的格式：

​ 将最小的值返回

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

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

​

内置函数：

• callable 判断对象是否可以被调用

• repr 返回一个对象string形式，也就是返回原来的样子（原形毕露）

• all 可迭代对象中，全部都是True返回True 像and

• any 可迭代对象中，与all相反，有一个True就返回True 像or

• print sep=' '字符串中，可以替换成别的字符 end='\n'可以添加空格（格式print(1, end=' ')

• list 转换列表

• dict 创建字典的几种方式dic = dict(one=1,two=2)等等

• abs 返回数据的绝对值如果是负数，转化成整数，如果是整数还是整数（可以配合for循环）

• sum 计算数字总和，str不可以进行计算，

• reversed 将一个可迭代对象翻转,返回翻转的迭代器

  ++++++++++++++++++++++++++++++++++重要的++++++++++++++++++++++++++++++++++++

• zip 拉链方法，可以将不同的数据类型汇总成一个元祖，按列取值，以最短的元祖返回值

• sorted 排序，加key大小排序

• map 映射函数，类似列表推导式的循环模式

• filter 过滤,相当于生成器表达式的筛选模式,返回一个迭代器

• reduce 进行赋值计算

• min 取最小值

• max 取最大值

​

内置函数使用方法：

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
  

​

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在进行排序
  

• 列表内字典键值不同排序进行排序：

  lst2 = [{'a': 1}, {'b': 7}, {'c': 9}, {'d': 2}, {'e': -9}]
  
  print(list(sorted(lst2,key=lambda x:x[[i for i in x][0]])))  #通过key找到key
  print(list(sorted(lst2,key=lambda x:[i for i in x.values()][0]))) #通过values直接找到值
  
  

​

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:key

• 使用方法：

  可迭代对象 = reduce（函数名,x:x）

  作用：

  ​ 先把列表中的前两个元素取出来，计算出结果进行保存，当进行到第二个元素传参时，将第一次计算完的 结果与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)
  

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))
  

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)
  # 结果：
  # (1, 'a')
  # (2, 'b')
  # (3, 'c')
  # (4, 'd')
  
  #zip可以转字典！！！
  l1 = [1,2,3,4]
  l2 = ['a','b','c','d','e']
  
  print(dict(zip(l1,l2)))