Python之内置函数（二）

内置函数二

1. 内置函数

   print(abs(-11))#绝对值函数--返回的都是正数
   #结果为 11
   
   enumerate--枚举("可迭代对象","序号的起始值")#默认的起始值是0
   lst=[1,2]
   print([i for i in enumerate(lst,10)])
   #结果为:[(10,1),(11,2)]
   
   print(max([1,2,5,7])) #求最大值
   #结果为：7
   print(min([1,2,3,33]))#求最小值
   #结果为：1
   print(sum([1,2],100))#求和
   #结果为：103
   
   #python2 和python3区别：
   #python3:
     #  g=range(0,10) 获取可迭代对象
    #   g.__iter__()
   #python2:
   #   range(0,10) 获取是一个列表
   #    xrange(0,10) 获取是一个可迭代对象
   
   from collection import Iterable,Iterator
   print(isinstance(g,Iterable))#判断是否是可迭代对象
   print(isinstance(g,Iterator))#判断是否是可迭代器
   
   print(sep=" ",end="
   ")#sep多个元素的连接符 end 结尾形式
   
   print(list("alex"))#列表是可迭代对象
   #结果为：["a","l","e","x"]
   print(dict((1,2),(2,3),(3,4)))
   #结果为:{1：2，2：3，3：4}
   
   #zip()拉链 --按照最少的进行合并
   lst1 = [1,2,3,4,5]
   lst2 = ['a',"b","c","d","f","e"]
   print(dict(list(zip(lst1,lst2))))
   #结果为{1:"a",2:"b",3:"c",4:"d",5:"e"}
   
   print(dict(zip(lst1,lst2)))
   #结果为：{1:"a",2:"b",3:"c",4:"d",5:"e"}
   
   print(dir(list))#查看 当前函数的方法
   

2. 重要的内置函数和匿名函数

   1. 匿名函数

      f=lambda x,y:(x,y)
      print(f(1,2))#调用函数并输出值
      print(f.__name__)#查看函数名
      #结果为： (1,2)  lambda
      
      print((lambda x:x)(2))#同一行定义 同一行调用
      #结果为：2
      #lambda 关键字
      #x,y 形参
      #：x+y 返回值--只能返回一个数据类型
      
      lst=[lambda i:i*i for i in range(10)]
      print(lst[2](2))
      #结果为：4
      #拆分 推导式
      lst=[]
      for i in range(20):
          def func(i):
              return i*i
          lst.append(func)#列表添加func内存地址
      print(lst[2](3))#调用 列表第二个函数 将3传值 计算结果为9
      
      lst=[lambda :i*i for i in range(10)]
      print(lst=[2]())
      #结果为：81
      #拆分
      lst=[]
      for i in range(10):
          def func()
          	return i*i
          lst.append(func)
       print(lst[2]())#函数无传参 i最终值是9 最后结果为81
      #总结： 一行函数 参数可以不写，返回值必须写，返回值只能返回一个数据类型
      
      

   2. 内置函数(重要)

      print(format(13,">20"))#右对齐
      print(format(13,"<20"))#左对齐
      print(format(13,"^20"))#居中
      print(format(13,"08b"))#十进制转二进制
      #结果为:00001101  08 代表从0开始 显示8位 b位二进制
      print(format(13,"08d"))#转十进制
      #结果为：00000013 08 代表从0开始 显示8位 d位十进制
      print(format(13,"08o"))#转8进制
      #结果为：00000015 08 代表从0开始 显示8位 o位八进制
      print(format(13,"08x"))#转十六进制
      #结果为：0000000d 08 代表从0开始 显示8位 x位十六进制
      print(bin(13))#转二进制 结果为：0b1101
      
      #filter()过滤
      lst=[1,2,3,4,5,6,7]
      def func(s):
          return s>3
      print(list(filter(func,lst)))
      #结果为：[4,5,6,7]
      #func就是自己定义的一个筛选条件，lst要迭代的对象
      
      lst=[1,2,3,4,5,6,7]
      print(list(filter(lambda x:x%2==1,lst)))
      #结果为：3 5 7
      
      #map()对象反射
      print(list(map(lambda x:x*x,[1,2,3,8,4,5])))
      #结果为：[1,4,6,64,16,25]
      #把list去掉 则为 map对象内存地址
      
      lst=[1,23,34,4,5,213,123,41,12,32,1]
      print(sorted(lst)) #升序
      print(lst)
      
      print(sorted(lst,reverse=True))#降序
      
      dic = {"key":1,"key1":2,"key3":56}
      print(sorted(dic,key=lambda x:dic[x],reverse=True))#key 是指定排序规则
      #["key3","key2","key1"]
      #将字典dic键传值给函数lambda 最后按着 字典值 降序 排序
      
      print(max([1,2,-33,4,5],key=abs)) #key指定查找最大值的规则
      #结果为：-33
      
      from functools import reduce
      #reduce 累计算
      print(reduce(lambda x,y:x-y,[1,2,3,4,5]))
      #结果为：-13
      #将 1 2 计算结果给了x 再进行计算