Python函数之内置函数II

Python函数之内置函数II

1.内置函数

下面要讲的内置函数非常重要，必需要记住的

• print 屏幕输出。

  ''' 源码分析
  def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
      """
      print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
      file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
      sep:   打印多个值之间的分隔符，默认为空格
      end:   每一次打印的结尾，默认为换行符
      flush: 立即把内容输出到流文件，不作缓存
      """
  '''
  
  # def print(self, *args, sep=' ', end='\n', file=None):
  # print(1, 2, 3)
  # print(1, 2, 3, sep=';')
  # print(1, 2, 3, sep='|')
  # print(1, end=' ')
  # print('barry', end='__')
  # print('改博')
  
  

• list tuple dict

  # 分别创建不同的数据类型
  # list
  # lst = list('abcd')
  # print(lst)
  
  tu1 = (11, 22, 33)
  print(list(tu1))
  lst = [11, 22, 33]
  print(tuple(lst))
  
  # 字典转化成列表
  # dic = {'name': 'barry', 'age': 25, 'hobby': 'girl'}
  # print(list(dic))
  
  # 列表转化成字典
  lst = [(1, 'barry'), (2, '小金'), (3, '树宏')]
  print(dict(lst))
  
  

• abs 返回绝对值

  i1 = -5
  print(abs(i1))
  

• sum求和

  # l1 = [22, 33, 11, 45]
  # # 元组，集合
  # print(sum(l1))
  
  print(sum([1, 2, 3], 100))  # 可以设置初始值
  

• zip 拉链方法

  l1 = [1, 2, 3, 4]
  s1 = 'abcde'
  tu1 = ('barry', '明天', '阿珍',)
  
  ret = zip(l1, s1, tu1)  # [(1, 'a', 'barry'), (2, 'b', '明天'),(3, 'c', '阿珍')]
  # print(ret)  # 迭代器
  for i in ret:
      print(i)
  

• format 格式转换

  # 十进制转化成二进制
  # print(format(10, 'b'))
  # print(format(10, '08b'))
  
  # print(format(10, 'o'))  # 十进制转化成8进制
  # print(format(10, 'x'))  # 十进制转化成16进制
  
  print(format('barry', '^20'))
  print(format('barry', '>20'))
  print(format('barry', '<20'))
  

• reversed 将一个序列进行反转，得到一个迭代器

  # s1 = 'barry'
  # s1 = [1, 2, 3]
  
  # print(reversed(s1))  # 迭代器
  ret = reversed(s1)
  print(list(ret))
  

​ 以下的内置函数就是内置函数中的极品函数

• min 最小值

  l1 = [2, 3, -1, -5, -10]
  获取这个列表的最小值
  
  print(min(l1))
  
  获取列表中所有元素的绝对值的最小值
  
    l1 = [2, 3, -1, -5, -10]
    def func(i):
        return abs(i)
  
  key一定是赋值一个函数名（函数的内存地址）
  
  ret = min(l1, key=func)
  print(ret)
  """
  带key的内置函数原理如下：
  比如min,它会自动的遍历可迭代对象里面的元素，每循环一次，将元素传给给指定的函数，然后按照返回值去进行筛选。
  
  第一次，min将l1中的2传递给func函数，返回值为abs(2) 即为 2 暂存到内存；
  第二次，min将l1中的3传递给func函数，返回值为abs(3) 即为 3 与上次暂存的2对比，留下最小的 2暂存到内存；
  第三次，min将l1中的-1传递给func函数，返回值为abs(-1) 即为 1 与上次暂存的2对比，留下最小的 1暂存到内存；
  以此类推，直到将所有的元素遍历完，结束。
  ！！！ 遍历的那个元素，返回那个元素。
  """
  
  优化
  
  l1 = [2, 3, -1, -5, -10]
  func = lambda x: abs(x)
  key一定是赋值一个函数名（函数的内存地址）
  ret = min(l1, key=lambda x: abs(x))
  print(ret)
  
  在优化
  l1 = [2, 3, -1, -5, -10]
  func = lambda x: abs(x)
  key一定是赋值一个函数名（函数的内存地址）
    ret = min(l1, key=abs)
    print(ret)
  
  例一；
  dic = {'c': 1, 'b': 3, 'a': 2}
  print(min(dic))  # 默认按照键 获取最小值
  
  将字典中最小的值获取到。
  ret = min(dic, key=lambda x: dic[x])
  print(dic[ret])
  
  例二：
  lst = [('barry', 24), ('xiaojin', 23), ('shuhong', 25)]
  print(min(lst)
  获取年龄最小的那个元组。
  
  ret = min(lst, key=lambda x: x[1])
  print(ret)
  
  获取年龄最小的那个人名。
  print(ret[0],ret[1])
  

• max 最大值,与min一模一样

• sorted 排序,生成一个新的对象，不会对原对象修改，默认从小到大，可以改变reverse参数从大到小，也可以加key自定制排序方法

  l1 = [2, 3, -1, -5, -10]
  
  基础操作
  print(sorted(l1))  # 从小到大,
  print(l1)
  print(sorted(l1,reverse=True))
  
  加key操作
  按照绝对值从小到大进行排序
  ret = sorted(l1, key=abs)
  print(ret)
  按照年龄进行排序
  lst = [('barry', 24), ('xiaojin', 23), ('shuhong', 25)]
  print(sorted(lst))
  ret = sorted(lst, key=lambda x: x[1])
  print(ret)
  ret = sorted(lst, key=lambda x: x[1],reverse=True)  # 从大到小
  print(ret)
  
  lst = ['西游记', '梁山泊与祝英台', '三国演义', '唐伯虎点秋香']
  按照每个字符串的长度进行从小到大排序
  
  ret = sorted(lst, key=len)
  print(ret)
  

• map 映射函数，可以加key，类似于列表推导式的循环模式。

• filter 筛选函数，可以加key, 类似于列表推导式的筛选模式。

  lst = [{'id': 1, 'name': 'alex', 'age': 18},
         {'id': 1, 'name': 'wusir', 'age': 17},
         {'id': 1, 'name': 'taibai', 'age': 16}, ]
  
  将年龄大于16的留下来。
  print([i for i in lst if i['age'] > 16])
  求两个列表对应位置的和组成的列表。
  lst1 = [1, 2, 3, 4, 5]
  lst2 = [2, 4, 6, 8, 10]
  
  列表推导式
  ret = [lst1[index] + lst2[index] for index in range(len(lst1))]
  print(ret)
  ret = map(lambda x, y: x + y, lst1, lst2)
  print(list(ret))
  
  filter
  ret = filter(lambda x: x['age'] > 16, lst)
  print(ret)
  print(list(ret))
  

• reduce 原来是 内置函数，现在已经不属于内置函数了，但是比较好用。

  from functools import reduce
  lst = [1, 2, 3, 4, 5]
  ret = reduce(lambda x, y: x + y, lst)
  
  """
  先获取1， 2  赋值给 x y ,  1 + 2 = 3
  然后！！！上一个执行的结果赋值给x, 把列表中的3复制给y  3 + 3 = 6
  然后！！！上一个执行的结果赋值给x, 把列表中的4复制给y  6 + 4 = 10 
  ......
  """
  
  ret = reduce(lambda x, y: x * 2 + y, lst)
  print(ret)