内置函数

基础数据类型相关

数字类型：
　　• int
　　• float
　　• bool
　　• complex 复数

        print(complex(2))                #（2+0j）
        print(complex(2,8))             #（2+8j）
        print(complex(2+8j))           #（2+8j）
        print(complex(2,8j))             #（-6+0j）

进制转换：

　　• bin 二进制
　　• oct 八进制
　　• hex 十六进制

数学运算：

   •  abs     # 绝对值
   •  divmod  # 商余      print(divmod(10,3))      #（3）
   •  round   # 小数保留且四舍五入  print(round(1.16,2))  #1.2
   •  pow     # 幂
                pow(x,y)   # x*y
                pow(x,y,z) # x**y%z      t = pow(3,2,4)   '
'  print(t)    # 1  (3**2==9   9%4 ==1)
   •  sum     # 求和
                print(sum(range(7)))     #21
                print(sum(range(7),-6))  #15  (21-6)    
   •  min     # 最小值
   •  max     # 最大值
                print(max(-9,1,5))          #最大值 5
                print(max(-9,1,5,key=abs))      #绝对值最大值   -9 （key= 函数名）
                print(max([-9,1000,100],[-8,1,5]))    #最大值 【-8,1,5】（列表等比值先看第一项） 

作用域相关：

　　• globals 全局变量（字典形式打印） {所有的全局变量：值， 所有函数名：内存地址}
　　• locals 局部变量（字典形式打印） {所有 局部变量：值， 所有 同一个函数内的函数名：内存地址}

迭代器、生成器相关：

　　• range
　　• iter
　　• next

其他：

　　• eval 和 input 组合用有安全隐患，如果要用，把代码写死。。。
　　• exec
　　• compile 编译 compile(source, filename, mode, flags, dont_inherit) 将一个字符串编译为字节代码

输入输出：

　　• input
　　• print

    print(self,*args,sep=' ‘,end = ’
',file = None)               
    print(value,........,sep = ' ‘,end = ’
',file = sys.stdout,flush = False)    
        file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
        sep:   打印多个值之间的分隔符，默认为空格
        end:   每一次打印的结尾，默认为换行符
        flush: 立即把内容输出到流文件，不作缓存        
        
        f = open('name','w',encoding='utf-8')
        print(123,456,sep = ',',file=f,flush = True)    #直接写入文件中
   
        import time
        for i in range(0,101,2):
           n = i // 2
           time.sleep(0.2)
           # 
 默认表示将输出的内容返回到第一个指针，这样的话，后面的内容会覆盖前面的内容
           print('
{}%%:{}'.at(i,'*'*n),'
' if i == 100 else '
{}%%:{}'.at(i,'*'*n),end='')
           
           
                            输出颜色：
                                    格式：print("33[前景色m    str     33[背景色m")           33[色号m

                                                print("33[31m    hello   33[40m")

                            前景色         背景色         颜色
                            ------------------------------------------
                            30                  40              黑色
                            31                  41              红色
                            32                  42              绿色
                            33                  43              黄色
                            34                  44              蓝色
                            35                  45              紫红色
                            36                  46              青蓝色
                            37                  47              白色

                            显示方式            意义（前景色）
                            ----------------------------------------------
                            0                           终端默认设置
                            1                           高亮显示
                            4                           使用下划线
                            5                           闪烁
                            7                           反白显示
                            8                           不可见

内存相关：

　　• hash 判断一个数据类型是否可哈希 不可哈希会报错 （字典键的内存寻址）
　　-----在一个程序执行的过程中，对同一个值hash的结果总是不变
　　• id

文件操作相关：

　　• open

模块相关：

　　• import 插入模块相关

帮助：

　　• help 查看所有的方法及其使用方法

　　　　help（） 所有 ‘q’退出

　　　　help（o）查看o对象的使用方法

调用相关：

　　▪ callable      # 返回True or False

查看内置属性：

　　• dir 只查看对象包含所有属性、方法名

数据结构相关

序列相关：
　　• list
　　• tuple

内置函数相关：

　　• reversed    倒序：反转一个序列对象，使其元素从后往前构建一个新的迭代器

    reversed  返回迭代器   不改变原列表，生成一个新的迭代器
    reverse   返回None   改变原列表   
        
    l = [1, 2, 3]
    res = reversed(l)           #生成一个新的res迭代器
    print(list(res))
    ---------
    l.reverse()         #把原列表改变
    print(l)

　　• slice 切片

 　　l = [1,2,3,4,5,6,7,8,9]
 　　s = slice(1,4,2)   切片的内置函数
 　　print(l[s])
 　　#[2, 4]
 　　l[1,4,2]  以前的切片可以理解成语法糖

字符串相关：

　　• str

　　• bytes  字节     网络编程的时候：能在网络上传递的必须是字节

    a = bytes('周',encoding='gbk')      中间网络传输的时候用的是  t
    print(a)                          b'xd6xdc'
    b = a.decode(encoding='utf-8')   另一台计算机收到后 解码， 

　　• bytearray   字符串长的时候用（修改）

　　对比较长的字符串做修改的时候，指定某一处进行修改，不会改变这个bytearray的内存地址
　　bytearray  创建一个，就不用创建，直接多次修改
        s = 'abcdefg'
        a = bytearray(s.encode('utf-8'))       # 把Unicode的str类型编码成utf-8的byte类型
        a[:2] = bytearray('xy'.encode('utf-8'))
        a[-2:] = bytearray('mn'.encode('utf-8'))      #可以多次操作，省内存（str模式修改一次，创建一个内存）
        print(s)
        print(a.decode('utf-8'))       # 把a由utf-8的byte类型解码成Unicode的str类型

　　• memoryview 

　　a = memoryview(bytes('周abcdefg',encoding='utf-8'))
    print(len(a))  #10     只用bytes和bytearray拿不到 print(bytes('a')) 拿到b'a'   print(bytearray('a')) 拿到bytearray(b'a')
    print(a[0])   #97 类似C语言指针功能，memoryview（obj） obj必须支持buffer protocol，
                    # python中原生的支持buffer protocol的有bytes和bytearray
    print(a[:4])   #<memory at 0x00000000021BC108>
    print(bytes(a[:3])) #b'xe5x91xa8'  是3个字节 utf-8 bytes类型， 需要解码才能得到汉字
    t = bytes(a[:3])
    print(t.decode('utf-8'))  #解码，拿到‘周’

　　• ord ord 和 chr 为互逆函数 把长度为 1 的字符串转换成 数字range（256） uniord

　　• chr chr()函数用一个范围在range（256）内的（就是0～255）整数作参数，返回一个对应的字符

    print(ord('a'))   # 97
    print(chr(97))    # a
    可以比较字母的大小（例子：乒乓球选对阵名单）

　　• ascii码

此函数跟repr()函数一样，返回一个可打印的对象字符串方式表示，当遇到非ASCII码是，就会输入x,u或U等字符
来表示，
跟python2里的repr()是等效的函数

    print(ascii('a'))  # 'a'  a字符串
    print(ascii(10))           #数字10
    print(ascii('akfjdk'))   # 'akfjdk'
    print(ascii(90000000000000000000000000000))  #90000000000000000000000000000
    print(ascii('b31'))           #'bx19'
    print(ascii('0x100'))  # '0x@0'

　　• repr

　　基本上和ascii码函数一样

            print(repr('a'))  # 'a'  a字符串
            print(repr(10))           #数字10
            print(repr('akfjdk'))   # 'akfjdk'
            print(repr(90000000000000000000000000000))  #90000000000000000000000000000
            print(repr('b31'))           #'bx19'
            print(repr('0x100'))  # '0x@'
            
    %r 用repr（）处理对象
    字符串拼接
    word = "I'm a teacher."
    %r
    print('I said: %r'%word)    ##I said: "I'm a teacher."
    %s
    print('I said: %s'%word)    ##I said: I'm a teacher.

数据集合相关：

　　• dict  字典
　　• set    集合
　　• frozenset

内置函数相关：

　　• len

　　• enumerate 枚举

    l = ['a','b','c']
    for i in enumerate(l,1):
        print(i)
    # (1, 'a')       得到的是元组，
    # (2, 'b')
    # (3, 'c')
    for i,j in enumerate(l,1):
        print(i,j)
    # 1 a           分别从元组取值
    # 2 b
    # 3 c

　　• all

    只要有0，空，None 就 False
    print(all([1,2,0]))                 #False
    print(all([1,2,None]))          #False
    print(all([1,2,'']))                #False
    print(all([1,2,3]))                 #True

　　• any

    只要有  非空 就  True
    print(any([None,'',0]))         #False
    print(any([1,'',None,0]))       #True

　　• zip 拉链函数 以短的为基准

    就像拉链一样，把每个对应的放到一个元组里面
    a = zip(['a','b','c','d'],('xy','z'),range(100))
    print(a)                         <zip object at 0x00000000024BAA88>
    print(type(a))                 <class 'zip'>
    print(list(a))

    #[('a', 'xy', 0), ('b', 'z', 1)]        第二个只有 2 个元素

　　• filter 过滤函数

    filter（）函数不改变可迭代对象原来的元素，只是元素个数<=原数量
    filter(func,iter)

    def func(n):
        if n > 3:
            return True
    t = filter(func,[1,2,3,4,5])
    print(type(t))           #<class 'filter'>
    print(list(t))           #[4,5]

    def func(n):
        if n < 3:
            return False        # Flase  返回的都是空    只有的True的才会放到新的迭代器里面
    t = filter(func,[1,2,3,4,5])
    print(list(t))      #[]

    def func(n):
        return n > 3            #可以直接返回 条件
    t = filter(func,[1,2,3,4,5])
    print(list(t))           #[4,5]


    def func(n):
        return n and n.strip()          # n 把None ， 0 过滤掉，  n.strip()把 ‘’ 过滤掉
    t = filter(func,['a',None,'',0,'0','b'])        # ‘0’ 不能过滤
    print(list(t))              ['a', '0', 'b']

　　• map（func ，iter1，iter2） 根据提供的函数对指定序列做映射

    新内容个数 = 原内容个数
    map() 和 filter() 区别：map不改变元素个数     可迭代对象的 元素 可能发生变化

    def f(x):
        return x**2
    ret = map(f,[1,2,3,4,5,6,7,8])      # map(函数，可迭代obj)          
    print(list(ret))                    # 返回：迭代器 
    #[1, 4, 9, 16, 25, 36, 49, 64]

　　• sorted(iterable,key,reverse) 

    生成一个新列表，不改变原列表
    sort 修改原列表顺序
    print(sorted([-5,3,-2,1,-4]))     #[-5, -4, -2, 1, 3]  #升序
    print(sorted([-5,3,-2,1,-4],reverse=True))     #[3, 1, -2, -4, -5] #倒序
    print(sorted([-5,3,-2,1,-4],key=abs,reverse=True))      #绝对值倒序        ( 凡是有key=None 的，都是默认 函数)
    #[-5, -4, 3, -2, 1]                 
    l = ['ajkhs',(1,2),'a',[1,2,3,4]]
    print(sorted(l,key=len,reverse=True))           # 各个元素之间必须有对比性（就是必须能比较大小，例如str和int不能比较，
    #['ajkhs', [1, 2, 3, 4], (1, 2), 'a']                    报错）