python 内置函数

1. 作用域相关
   1. locals()

      获取局部作用域的变量的字典

      def func():
          a = 1
          b = 2
          print(locals())
      func()

   2. globals()

      #获取全局作用域的变量的字典
      print(globals())

2. 数据类型
   1. bool()

      #转为bool型
      bool('a')
      True：非0数，非空序列
      False：0，空序列

   2. int()

      #转为整型
      int('1235')

   3. float()

      #转为浮点型
      float(1243)

   4. complex()

      #复数对象
      c = complex(1,2)    #1+2j
      print(c)

3. 进制转换
   1. bin()

      #转为二进制
      bin(123)

   2. oct()

      #转为八进制
      oct(123)

   3. hex()

      #转为十六进制
      hex(123)

4. 数学运算
   1. abs()

      #获得绝对值
      abs(-10)

   2. divmod()

      #获得商余
      print(divmod(100,3))    #获得商33，余数1

   3. round()

      #精确小数位数
      round(3.14159,2)    #得到3.14

   4. pow()

      #幂运算
      pow(2,3)    #得到8
      
      pow(2,3,3)　　#2的3次方再取余3得到余数

   5. sum()

      #求和
      sum([1,2,3,4],0）    #sum(可迭代对象，起始值）
      #得到10

   6. min()

      #求最小值
      min([2,4,56,-2,1]）    #-2
      
      min([2,4,56,-2,1],key=abs）    #可以用key指定一个函数，它会作用在每一个元素，然后根据作用后的元素求得符合条件的值，然后返回原来的元素
      #返回1

   7. max()

      #求最大值
      max([2,4,56,-200,1]）    #56
      
      max([2,4,56,-200,1],key=abs）    #可以用key指定一个函数，它会作用在每一个元素，然后根据作用后的元素求得符合条件的值，然后返回原来的元素
      #返回200

5. 序列相关（列表、元组、字符串以及相关函数）
   1. tuple()

      #将可迭代对象转成元组
      tuple([1,2,3])

   2. reversed()

      #反转序列，然后返回
      reversed([1,2,3])    #3,2,1

   3. slice()

      #切片，和[::]一样
      li [1,2,3,4,5]
      sli = slice(0，2)　　#这里得到的是切片规则
      li[sli] 
      

   4. str()

      #转为字符串
      str(123)

   5. format()

      #格式化
      
      #字符串，对齐方式：<左对齐，>右对齐，^居中对齐
      format('test','^20')    #全部长度20，test居中
      
      #整数，参数：b二进制,c unicode字符,d十进制,o八进制,x十六进制,X十六进制大写,n和d一样
      format(3,'b')
      
      #浮点数，参数：e,E,f,F,g,G,n,%
      e 科学计数法，默认保留6位小数
      0.2e 保留两位
      
      f 小数点计数法，默认保留6位
      0.3f 保留3位

   6. bytes()

      转为字节码类型
      bytes('hi')

   7. bytearray()

      #获得一个可变的字节码数组
      bytearray('你好',encoding='utf-8')

   8. memoryview()

      memoryview 是一个内置类，它能让用户在不复制内容的情况下操作同一个数组的不同切片。
      
      内存视图其实是泛化和去数学化的 NumPy 数组。它让你在不需要复制内容的前提下，在数据结构之间共享内存。
      
      memoryview.cast 会把同一块内存里的内容打包成一个全新的 memoryview 对象给你。
      
      ##############################
      #通过改变数组中的一个字节来更新数组里某个元素的值
      import array
      
      numbers = array.array('h', [-2, -1, 0, 1, 2])
      memv = memoryview(numbers)
      memv_oct = memv.cast('B')
      memv_oct[5] = 4
      print(numbers)
      
      #结果：array('h', [-2, -1, 1024, 1, 2])

   9. ord()

      #字符串转ascii
      ord('a')

   10. chr()

       #ascii转字符
       chr(97)

   11. ascii()

       返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符
       
       ascii('你好aaa')

   12. repr()

       #将对象转化为供解释器读取的形式
       
       repr(obj)

6. 数据集合
   1. dict()
   2. set()
   3. frozenset()
7. 数据结构相关内置函数
   1. len()
   2. enumerate()

      #用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
      
      seq = ['one', 'two', 'three']
      for i, element in enumerate(seq):
           print(i, element)

   3. all()

      #判断是否有含False
      
      print(all([1,2]))    #True，没有
      
      print(all([1,2,0]))    #False，有

   4. any()

      #和all相反，判断是否有含True
      
      print(any([0]))    #False，没有
      
      print(any([0,1]))    #True，有

   5. zip()

      #将多个序列的对应位置的元素组成一个元组，返回迭代器，长度由最短的决定
      
      li = [1,2,3]
      li2 = ['a','b','c','d']
      
      for i in zip(li,li2):
          print(i)
      
      #结果
      (1,'a')
      (2,'b')
      (3,'c')

   6. filter()

      #过滤器，返回一个迭代器
      
      ret = filter(lambda x:x%2==1,[1,4,6,7,9,11])    #返回质数
      
      #参数1为一个判断是否满足条件的函数，参数2一个序列

   7. map()

      #把可迭代对象的每个元素都执行一遍给定的函数，然后返回新元素组成的迭代器
      
      ret = map(abs,[1,-1,3,2])

   8. sorted()
8. 反射
   1. hasattr()
   2. getattr()
   3. setattr()
   4. delattr()
9. 面向对象相关
   1. classmethod
   2. staticmethod
   3. property
   4. isinstance()
   5. issubclass()
   6. super()
   7. object
   8. type()

      #返回对象的类型
      type(obj)

10. 迭代器/生成器
    1. iter()
    2. range()
    3. next()
11. 其他
    1. dir()

       #查看对象拥有的方法
       
       dir([12])

    2. callable()

       #判断是否可调用
       
       print(callable(print))

    3. help()

       #返回函数对应的注释
       
       help(print)

    4. __import__()

       #导入模块，一般用import
       time = __import__('time')

    5. open()
    6. writable()
    7. readable()
    8. id()

       #获取对象内存地址
       id(obj)

    9. hash()

       #获取哈希值
       hash(obj)

    10. input()
    11. print()

        参数 end='...'    指定输出的结尾
                sep='...'    指定输出的值之间的分隔符
                file='文件句柄'    可以用来输出到文件

    12. eval()

        #执行字符串形式代码，可以得到返回值
        
        ret = eval('1+2+3')

    13. exec()

        #执行字符串形式代码，得不到结果
        
        exec('print(1)')

    14. compile

        #将常用的代码先编译，然后再执行
        
        com = compile(code,'','exec')
        exec(com)