精华内容
下载资源
问答
  • Python 常用内置函数

    2019-10-09 22:18:31
    最近去面试遇到面试官问Python常用内置函数,在这里学习一下,还没学习到的慢慢做补充。基于Python3 官方网站:https://docs.python.org/3/library/functions.html?highlight=built#ascii 英文好的同学可以直接去...

    最近去面试遇到面试官问Python常用内置函数,在这里学习一下,还没学习到的慢慢做补充。基于Python3

    官方网站:https://docs.python.org/3/library/functions.html?highlight=built#ascii

    英文好的同学可以直接去官网阅读哦,目前3.8(3.9还在开发中)为止,共69个常用内置函数。

                                                                           python内置函数                                                                                                    

    Python abs()函数 Python delattr()函数 Python hash()函数 Python memoryview()函数 Python set()函数
    Python all()函数 Python dict()函数 Python help()函数 Python min()函数 Python setattr()函数
    Python any()函数 Python dir()函数 Python hex()函数 Python next()函数 Python slice()函数
    Python ascii()函数 Python divmod()函数 Python id()函数 Python object()函数 Python sorted()函数
    Python bin()函数 Python enumerate()函数 Python input()函数 Python oct()函数 Python staticmethod()函数
    Python bool()函数 Python eval()函数 Python int()函数 Python open()函数 Python str()函数
    Python breakpoint()函数 Python exec()函数 Python isinstance()函数 Python ord()函数 Python sum()函数
    Python bytearray()函数 Python filter()函数 Python issubclass()函数 Python pow()函数 Python super()函数
    Python bytes()函数 Python float()函数 Python iter()函数 Python print()函数 Python tuple()函数
    Python callable()函数 Python format()函数 Python len()函数 Python property()函数 Python type()函数
    Python chr()函数 Python frozenset()函数 Python list()函数 Python range()函数 Python vars()函数
    Python classmethod()函数 Python getattr()函数 Python locals()函数 Python repr()函数 Python zip()函数
    Python compile()函数 Python globals()函数 python map()函数 Python reversed()函数 Python __import__()函数
    Python complex()函数 Python hasattr()函数 Python max()函数 Python round()函数  

    终于过完一遍了,零零碎碎用了十多天时间。后期学习中工作中再去熟练掌握。

     

     

     

     

     

                                                             

     

    展开全文
  • Python常用内置函数

    2020-01-28 16:36:05
    Python常用内置函数:compile(), map(), reduce(), zip(), range(), filter(), eval()

    compile()

    # compile()_39
    
    """
        compile()
            compile(source, filename, mode[, flags[, dont_inherit]])
            compile() 函数将一个字符串编译为字节代码。
            
            source -- 字符串或者AST(Abstract Syntax Trees)对象。。
            filename -- 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
            mode -- 指定编译代码的种类。可以指定为 exec, eval。
            flags -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。。
            flags和dont_inherit是用来控制编译源码时的标志
    """
    
    # 将语句转换为字节码文件,exec() 函数能运行该字节码文件
    var0 = compile('print("I Love You.")', '', 'exec')  # <code object <module> at 0x03420548, file "", line 1>
    exec(var0)  # I Love You.
    
    # 将该字符串转换为字节码文件,eval() 函数能将该字节码文件的结果计算出来
    var1 = compile('10 * 10', '', 'eval')  # <code object <module> at 0x034A05A0, file "", line 1>
    eval(var1)  # 100
    
    

    Link:菜鸟教程_compile()

    eval()

    # eval()_39
    
    """
        eval()
            eval(expression[, globals[, locals]])
            eval() 函数用来执行一个字符串表达式,并返回表达式的值。
    """
    
    # 可以吧 str 转换为 int 型
    num0 = eval('100')  # 相当于 int('100')
    
    # ================================================================== #
    # eval() 中不允许有以0开头的数值:SyntaxError: invalid token
    # ================================================================== #
    
    # eval('0100')  # int('0100') 不报错
    
    # 能计算 str 里的值
    num1 = eval('10 * 10')  # 100
    
    # 当 str 的表达式为 num1, num2, ...,能做解包操作
    num2, num3 = eval('100, 200')  # 类似 (100, 200).split(',')
    
    # 可用于值的输入操作
    # 注意数值间使用 ',' 分隔
    num4, num5 = input("请输入两个数:")
    
    # 类似的可以写为
    num6, num7 = map(int, input("请输入两个数值:").split(','))
    
    

    Link:菜鸟教程_eval()

    filter()

    # filter()_35
    
    """
        filter()
            filter(function, iterable)
            filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
            该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,\
            \ 然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
    """
    
    def is_not_0(args):
        return True if args is not 0 else False
    
    # 筛出0
    iter0 = filter(is_not_0, [2, 5, 0, 9, 6, 0, 7])  # <filter object at 0x035FCAF0>
    
    # 简单实现filter()
    
    def new_filter(function, iterable):
        
        result = []
        
        # 将返回 True 的元素放到新列表中
        for element in iterable:
            if function(element):
                result.append(element)
        
        return result
                
    iter1 = new_filter(is_not_0, [2, 5, 0, 9, 6, 0, 7])  # [2, 5, 9, 6, 7]
    
    

    Link:菜鸟教程_filter()

    map()

    # map()_35
    
    """
        map()
            map(function, iterable, ...)
            map() 会根据提供的函数对指定序列做映射。
            第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。
    """
    
    def add_one(args):
        # args add one and returns
        return args + 1
    
    iter1 = map(add_one, range(10))  # <map object at 0x039BC870>
    iter1 = list(iter1)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    # ========================================================================================= #
    # 不报错当进行输出时报:TypeError: add_one() takes 1 positional argument but 2 were given
    # ========================================================================================= #
    iter2 = map(add_one, [0, 1, 2, 3], [1, 2, 3, 4])  # <map object at 0x03ADCAF0>
    
    def new_add_one(args0, args1):
        args0 += 1
        args1 += 1
    
    # ========================================================================================= #
    # map() 得到的值由参数一中的函数所确定,输出得到:[None] * 4
    # ========================================================================================= #
    iter3 = map(new_add_one, range(4), range(1, 5))  # <map object at 0x03DECF70>
    
    def over_add_one(args0, args1):
        return args0 + 1, args1 + 1
    
    iter4 = map(over_add_one, range(4), range(1, 5))  # 输出得到 [(1, 2), (2, 3), (3, 4), (4, 5)]
    
    
    # 可以使用 map() 构成简单的 zip(),利用 map() 多序列传参的特点
    
    def zip_func(args0, args1):
        return (args0, args1)  # 括号可有可无
    
    iter5 = list(map(zip_func, range(10), range(10)))  # [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]
    
    # 也可以使用匿名函数
    
    iter6 = list(map(lambda x, y: (x, y), range(10), range(10)))
    
    

    Link:菜鸟教程_eval()

    range()

    # range()_37
    
    """
        range()
            range(start, stop[, step])
            python range() 函数可创建一个整数列表,一般用在 for 循环中。
    """
    
    # 长度为:10
    iter0 = range(10)
    
    # 开始值:5
    iter1 = range(5, 10)
    
    # 步长为:2
    iter2 = range(0, 10, 2)
    
    

    Link:菜鸟教程_range()

    zip()

    # zip()_38
    
    """
        zip()
            zip([iterable, ...])
            zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
            如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
    """
    
    iter0 = zip(range(10), range(10, 0, -1))  # <zip object at 0x0318F440>
    
    iter1 = zip(*iter0)  # <zip object at 0x035EDEB8>
    iter1 = list(iter1)  # [(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (10, 9, 8, 7, 6, 5, 4, 3, 2, 1)]
    
    

    Link:菜鸟教程_zip()

    reduce()

    # reduce()_35
    
    from functools import reduce
    
    """
        reduce()  # functools
            reduce(function, iterable[, initializer])
            reduce() 函数会对参数序列中元素进行累积。
            函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,\
            \ 得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。
    """
    
    def x_add_y(args0, args1):
        return args0 + args1
    
    # 执行过程:先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。
    iter0 = reduce(x_add_y, range(10))  # 类似 sum(range(-10))
    
    # 使用匿名函数
    
    iter1 = reduce(lambda x, y: x + y, range(10))
    
    

    Link:菜鸟教程_reduce()

    例子

    # 2.5_39
    
    from math import (cos, sqrt, pi)
    
    # 1
    # 用户输入一个三位自然数,计算并输出其百位,十位,个位上的数字。
    
    def HDU():
        
        # 直接求值
        num = int(input("请输入一个三位自然数:"))
        hundred, decade, unit = num // 100, num // 10 % 10, num % 10  # 求百位,十位,个位
        
        # 使用 divmod() 函数
        """
            divmod()
                divmod(a, b)
                函数接收两个数字类型(非复数)参数,返回一个包含商和余数的元组(a // b, a % b)
                
                如果参数 a 与 参数 b 都是整数,函数返回的结果相当于 (a // b, a % b)。
                如果其中一个参数为浮点数时,函数返回的结果相当于 (q, a % b),q 通常是 math.floor(a / b),但也有可能是 1 ,比小,不过 q * b + a % b 的值会非常接近 a。
                如果 a % b 的求余结果不为 0 ,则余数的正负符号跟参数 b 是一样的,若 b 是正数,余数为正数,若 b 为负数,余数也为负数,并且 0 <= abs(a % b) < abs(b)。
        """
        # hundred, temp = divmod(num, 100)
        # decade, unit = divmod(temp, 10)
        
        # =========================================================================================================================================================== # 
        # 使用 map() 函数
        # =========================================================================================================================================================== #
        
        # hundred, decade, unit = map(int, num)
        
        return {'输入': num, '百位': hundred, '十位': decade, '个位': unit}  # 返回字典
    
    
    # 2
    # 已知三角形的两边长及其夹角,求第三边长
    
    def third_side():
        
        fir_side, sec_side, angle = map(float, input("请输入两条边及其夹角:"))
        
        thi_side = sqrt(fir_side ** 2 + sec_side ** 2 - 2 * fir_side * sec_side * cos(angle * (pi / 180)))
        
        return "第三边长为:" + str(thi_side)
    
    
    # 3
    # 任意输入三个英文单词,按照字典顺序依次输出
    
    def order_word():
        
        fir_word, sec_word, thi_word = input("请输入三个英文单词:").split(',')
        min_len = min([len(fir_word), len(sec_word), len(thi_word)])
        fir_num, sec_num, thi_num = 0, 0, 0
        
        for i in range(min_len):
        
            if fir_word[i] < sec_word[i]:
                fir_num += 1
            else:
                sec_num += 1
            
            if fir_word[i] < thi_word[i]:
                fir_num += 1
            else:
                thi_num += 1
            
            if sec_word[i] < thi_word[i]:
                sec_num += 1
            else:
                thi_num += 1
            
        if fir_num > sec_num > thi_num:
            return {'fir_word': fir_word, 'sec_word': sec_word, 'thi_word': thi_word}
        
        if fir_num > thi_num > sec_num:
            return {'fir_word': fir_word, 'sec_word': thi_word, 'thi_word': sec_word}
        
        if sec_num > fir_num > thi_num:
            return {'fir_word': sec_word, 'sec_word': fir_word, 'thi_word': thi_word}
        
        if sec_num > thi_num > fir_num:
            return {'fir_word': sec_word, 'sec_word': thi_word, 'thi_word': fir_word}
        
        if thi_num > fir_num > sec_num:
            return {'fir_word': thi_word, 'sec_word': fir_word, 'thi_word': sec_word}
        
        if thi_num > sec_num > fir_num:
            return {'fir_word': thi_word, 'sec_word': sec_word, 'thi_word': fir_word}
        
        # =========================================================================================================================================================== # 
        # 使用 sorted() 函数
        # =========================================================================================================================================================== #
        
        # fir_word, sec_word, thi_word = sorted([fir_word, sec_word, thi_word])
        # return {'fir_word': fir_word, 'sec_word': sec_word, 'thi_word': thi_word}
    
    
    展开全文
  • python 常用内置函数

    2020-06-07 01:05:36
    python 常用内置函数0x01 版本0x02 int()函数0x03 oct()0x04 hex()0x05 bin()0x06 eval()0x07 ord()0x08 chr()0x09 unichr()0x0a all()0x0b repr(object)0x0c execfile()0x0d filter()0x0e slice() 0x01 版本 1、...

    0x01 版本

    1、实验所采用版本为:python3.x

    2、本次主要查看了一下python的内置函数用法,参考菜鸟教程:https://www.runoob.com/python/python-built-in-functions.html

    3、其中进制转换类型的在编写算法类型的时候非常重要,自我认为比较重要的几个内置函数(也是自己运用的不熟练的)有eval()、all()、repr()、exec()、filter()、slice(),掌握好了常用的内置函数真的能事半功倍!

    在这里插入图片描述

    0x02 int()函数

    int() 函数用于将一个字符串或数字转换为整型。
    1、int()

    #当不传参数时,返回结果为整数0,类型为:int
    >>>print(int())
    >0
    >>>print(type(int()))
    <class 'int'>
    

    2、int(x)

    #当传递一个参数x时,x为字符串或者整数,返回的一定是int型
    >>>print(int(10))
    10
    >>>print(type(10))
    <class 'int'>
    >>>print(int('10'))
    10
    >>>print(type('10'))
    <class 'str'>
    >>>print(type(int('10')))
    <class 'int'>
    >>>print(int(0xa0))
    160
    >>>print(type(0xa0))
    <class 'int'>
    >>>print(int('0xa0'))
    ValueError: invalid literal for int() with base 10: '0xa0'
    >>>print(int(eval('0xa0')))
    160
    >>>print(type(int(eval('0xa0'))))
    <class 'int'>
    

    0x03 oct()

    oct() 函数将一个整数转换成8进制字符串。

    #参数有且只能有一个整型,返回值为8进制字符串型
    >>>print(oct(10))
    0o12
    >>>print(type(oct(10)))
    <class 'str'>
    

    0x04 hex()

    hex()其他进制转换为十六进制,以字符串形式返回

    #参数有且只能有一个整型,返回值为16进制字符串型
    >>>print(hex(255))
    0xff
    >>>print(type(hex(255)))
    <class 'str'>
    

    0x05 bin()

    bin()将int型或long int型转为二进制,以字符串形式返回.

    0x06 eval()

    eval() 函数用来执行一个字符串表达式,并返回表达式的值。

    #用法:
    eval(expression[, globals[, locals]])
    expression -- 表达式。
    globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
    locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
    >>>x = 7
    >>> eval( '3 * x' )
    21
    >>> eval('pow(2,2)')
    4
    >>> eval('2 + 2')
    4
    >>> n=81
    >>> eval("n + 4")
    85
    #其他进制字符串  -->  十进制整数
    >>> eval('0x0c')
    12
    #才外eval()函数也是一个及其危险的函数,他也可以执行系统命令
    >>>eval("__import__('os').system('ipconfig')")
    killer\administrator
    

    0x07 ord()

    ord()函数是 chr() 函数(对于8位的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配对函数,它以一个字符(长度为1的字符串)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值,如果所给的 Unicode 字符超出了你的 Python 定义范围,则会引发一个 TypeError 的异常。

    #返回一个字符对应的十进制整数
    #字符 -->  十进制整数
    >>>ord('a')
    97
    >>> ord('b')
    98
    >>> ord('c')
    99
    

    0x08 chr()

    chr() 用一个范围在 range(256)内的(就是0~255)整数作参数,返回一个对应的字符。

    #返回值是当前整数对应的 ASCII 字符
    #整数  -->  字符
    >>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
    0 1 a
    >>> print chr(48), chr(49), chr(97)         # 十进制
    0 1 a
    

    0x09 unichr()

    unichr() 函数 和 chr()函数功能基本一样, 只不过是返回 unicode 的字符。

    0x0a all()

    函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE,如果是返回 True,否则返回 False。

    #元素除了是 0、空、None、False 外都算 True。
    #例如:列表、元组等,若有一个为假,则返回False;空元组、空列表返回值为True,这里要特别注意。
    >>> all(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
    True
    >>> all(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
    False
    >>> all([0, 12, 3])          # 列表list,存在一个为0的元素
    False
       
    >>> all(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
    True
    >>> all(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
    False
    >>> all((0, 1, 2, 3))          # 元组tuple,存在一个为0的元素
    False
       
    >>> all([])             # 空列表
    True
    >>> all(())             # 空元组
    True
    

    0x0b repr(object)

    将对象转化为供解释器读取的形式,返回一个对象的 string 格式

    >>>s = 'RUNOOB'
    >>> repr(s)
    "'RUNOOB'"
    >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
    >>> repr(dict)
    "{'google': 'google.com', 'runoob': 'runoob.com'}"
    >>>
    

    0x0c execfile()

    python3 删去了 execfile(),代替方法如下:
    with open('test1.py','r') as f:
    		exec(f.read())
    

    0x0d filter()

    filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。

    #该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
    #python2放回的直接是列表,python3返回的是迭代器对象,需要转换成列表。
    def is_sqr(x):
    	return math.sqrt(x) % 1 == 0
    newlist = filter(is_sqr, range(1, 101))
    print(list(newlist))
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    

    0x0e slice()

    slice(start, stop, step):函数实现切片对象,主要用在切片操作函数里的参数传递。

    #slice(start, stop, step):函数实现切片对象,主要用在切片操作函数里的参数传递。
    data = [1,2,3,4,5,6,7,8]
    print(data[slice(1,8,3)])
    [2, 5, 8]
    
    展开全文
  • python常用内置函数

    2019-09-29 02:14:03
    python常用内置函数 数学运算函数: abs() 返回数字的绝对值 divmod() 计算两个数的商和余数,用元组返回 pow() 返回 xy(x的y次方) 的值 sum() 求和计算。 bin() 返回一个整数 int ...

    python常用内置函数

     

    数学运算函数:

     abs()  返回数字的绝对值  divmod()  计算两个数的商和余数,用元组返回  pow()  返回 xy(x的y次方) 的值
     sum()  求和计算。  bin()  返回一个整数 int 或者长整数 long int 的二进制表示  oct()  将一个整数转换成8进制字符串。
     round()  返回浮点数x的四舍五入值。  long()  将数字或字符串转换为一个长整型  hex()  将10进制整数转换成16进制整数。

     

     

     

    类型转换函数:

     str()  函数将对象转化为String的形式。  int()   函数用于将一个字符串会数字转换为整型。  tuple()  将列表转换为元组。
     bool()  参数转换为布尔类型,如果没有参数,返回 False  float()  将整数和字符串转换成浮点数。  list()  将元组转换为列表

     

     

    序列操作函数:

     min()  返回给定参数的最小值,参数可以为序列。  sorte()  对所有可迭代的对象进行排序操作。  len()  返回对象(字符、列表、元组等)长度或项目个数
     filter()  用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表  set()  创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
     zip()  用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
     reversed()  用于反向排序列表中元素  enumerate()  将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中

     

     

     

    输入输出函数:

     input()  用来获取控制台输入,输入的值必须是一个合法的python表达式  print()  用于打印输出  open()  打开一个文件,创建一个file对象
     file()  用于创建一个 file 对象,它有一个别名叫 open()  raw_input()  接收控制台输入的内容,可接收所有的类型    

     

     

    创建函数:

     iter()  用来生成迭代器。  range()  创建一个整数列表,一般用在 for 循环中。  dict()  用于创建一个字典。
     exec()  执行储存在字符串或文件中的Python语句,相比于 eval,exec可以执行更复杂的 Python 代码  bytearray()  返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256。
     complex()  创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。。  xrange()  用法与 range 完全相同,所不同的是生成的不是一个数组,而是一个生成器。

    获取函数:

     id()  用于获取对象的内存地址。  getattr()  返回一个对象属性值。  help()  用于查看函数或模块用途的详细说明。
     next()  返回迭代器的下一个项目。  memoryview()  返回给定参数的内存查看对象(Momory view)。  hash()  用于获取取一个对象(字符串或者数值等)的哈希值。
     vars()  返回对象object的属性和属性值的字典对象。  globals()  以字典类型返回当前位置的全部全局变量。  max()  返回给定参数的最大值,参数可以为序列。
     property()  在新式类中返回属性值。  ord()  返回一个字符对应的ASCII或者 Unicode值  staticmethod()  返回函数的静态方法
     frozenset()  返回一个不可变的集合,不能再添加或删除任何元素。  locals()  以字典类型返回当前位置的全部局部变量。  unichr()  返回unicode字符
     map()  根据提供的函数对指定序列做映射。 第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。  dir()  函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

    判断函数:

     issubclass()  判断参数 class 是否是类型参数 classinfo 的子类  hasattr()  用于判断对象是否包含对应的属性。  isinstance()  判断一个对象是否是一个已知的类型,类似 type()。
     any()  用于判断给定的可迭代参数 iterable 是否全部为空对象,如果都为空、0、false,则返回 False,如果不都为空、0、false,则返回 True。  all()   函数用于判断给定的可迭代参数 iterable 中的所有元素是否不为 0、''、False 或者 iterable 为空,如果是返回 True,否则返回 False
     callable()  检查一个对象是否是可调用的。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。  cmp()  用于比较2个对象,如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

    操作函数:

     delattr()  用于删除属性。  setattr()  对应函数 getatt(),用于设置属性值,该属性必须存在。  slice()  切片分割对象,用在切片操作函数里的参数传递。
     repr()  将对象转化为供解释器读取的形式。  compile()  将一个字符串编译为字节代码。  eval()  执行一个字符串表达式,并返回表达式的值
     execfile()  用来执行一个文件。  super()  调用下一个父类(超类)并返回该父类实例的方法  reload()  重新载入之前载入的模块
     type()  如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。  format()  格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
     basestring()  是 str 和 unicode 的超类(父类),也是抽象类,因此不能被调用和实例化,但可以被用来判断一个对象是否为 str 或者 unicode 的实例  classmethod()  classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。
     chr()  用一个范围在 range(256)内的(就是0~255)整数作参数,返回一个对应的字符  __import__()  动态加载类和函数 。 如果一个模块经常变化就可以使用 __import__() 来动态载入。
     reduce()  对参数序列中元素进行累积。 函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给reduce中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。

    下面是函数的详细介绍:


    函数名:abs()

    语法:

    abs( x )

    参数:数值表达式

    返回值:函数返回x(数字)的绝对值。

    代码示例:

    print ("abs(-45) : ", abs(-45))
    print ("abs(100.12) : ", abs(100.12))

    函数名:divmod()

    语法:

    divmod(a, b)

    参数:a,b均为数值

    返回值:一个包含商和余数的元组 例如(3,1),其中3是商,1是余数

    代码示例:

    divmod(7, 2)

    函数名:pow()

    语法:

    pow(x, y)

    参数:x,y均为数值

    返回值:返回结果值,为数值类型

    代码示例:

    pow(7, 2)

    函数名:sum()

    语法:

    sum(a,b)

    参数:a为元素为数值的可迭代的对象, b为一个数值类型的参数,b可不写,不写时默认为0

    返回值:返回值为迭代对象相加的和加上第二个参数,为数值类型

    代码示例:

    a = sum((2, 3, 4), 1)

    函数名:bin()

    语法:

    bin(x)

    参数:x为数值类型

    返回值:返回值为二进制的表示,是字符串类型

    代码示例:

    bin(12)

    函数名:oct()

    语法:

    oct(x)

    参数:x为数值类型

    返回值:返回值为八进制表示,是字符串类型

    代码示例:

    oct(11)

    函数名:round()

    语法:

    1
    round( m ,n  )

    参数:m为要四舍五入的值,为数值类型,n是保留的位数,为int类型

    返回值:返回值为数值类型

    代码示例:

    1
    round( 10.265 ,2  )

    函数名:long()

    语法:

    1
    long(x, y)

    参数:x为字符串或数值类型,b为进制数,默认10

    返回值:结果为数值类型

    代码示例:

    long(1)

    函数名:hex()

    语法:

    hex(x)

    参数:x为十进制数值

    返回值:十六进制的字符串

    代码示例:

    hex(11)

    函数名:str()

    语法:

    str(x)

    参数:x为对象

    返回值:返回字符串

    代码示例:

    str(object)

    函数名:int()

    语法:

    int(x,y)

    参数:x为字符串类型

    返回值:数值类型

    代码示例:

    int("111111")

    函数名:tuple()

    语法:

    tuple( seq )

    参数:seq为列表

    返回值:返回元组

    代码示例:

    tuple([1,2,3,4])

    函数名:bool()

    语法:

    bool(x)

    参数:x为要转换的参数,可以是数值或者string

    返回值:返回值为boolean类型,当参数为0或者空或者""的时候,返回false

    代码示例:

    bool("")
    bool(0)

    函数名:float()

    语法:

    float(x)

    参数:x为数值或者String

    返回值:返回值为浮点数

    代码示例:

    float("1")

    函数名:list()

    语法:

    list( seq )

    参数:seq为元组

    返回值:返回数组

    代码示例:

    list(("12","456","789"))

    函数名:min()

    语法:

    min( x, y, z, .... )

    参数:参数为序列或者集合

    返回值:返回最小值

    代码示例:

    min(("12","456","789"))

    函数名:sorted()

    语法:

    sorted(iterable, cmp, key, reverse)

    参数:iterable为要排序的序列,cmp为比较函数,key为用来进行比较的元素,reverse为升序或者降序,默认为false降序

    返回值:返回排好序的序列

    代码示例:

    #对元组进行排序
    sorted((12,123,56),reverse = True)
    #利用cmp函数排序
    sorted([('b',2),('a',1),('c',3),('d',4)], cmp=lambda x,y:cmp(x[1],y[1]))
    #利用key排序
    sorted([('b',2),('a',1),('c',3),('d',4)], key=lambda x:x[1])

    函数名:len()

    语法:

    len( s )

    参数:s为字符、列表元组等

    返回值:返回数值类型

    代码示例:

    len("xtyz")

    函数名:filter()

    语法:

    filter(function, iterable)

    参数:第一个参数为函数,函数返回布尔类型, 第二个参数为可迭代对象

    返回值:返回过滤后的集合

    代码示例:

    1
    2
    3
    4
    5
    6
    def  tt (parm):
        return parm < 7
     
    a = filter(tt, [9,8,7,6,5,4,3])
     
    print(list(a))

    函数名:set()

    语法:

    1
    set(x)

    参数:x为可迭代对象

    返回值:返回一个不重复的元素集合

    代码示例:

    复制代码
    a = set("9876554321")
    print(a)
    #可以用来计算交集,并集,差集等
    x = set("987654")
    y = set("654321")
    
    print(x&y)#交集
    print(x|y)#并集
    print(x-y)#差集
    复制代码

    函数名:zip()

    语法:

    zip(a,b,c,d.....)

    参数:参数为多个可迭代对象

    返回值:返回打包好的元组集合,元素合数与长度最短的迭代对象相同

    代码示例:

    复制代码
    x = "987654"
    y = "654321"
    print(list(zip(x,y)))
    
    x = [1,2.3]
    y = [4,5,6]
    print(list(zip(x,y)))

    #解压
    z = zip(x,y)
    print(zip(*z))
    复制代码

    函数名:reverse()

    语法:

    list.reverse()

    参数:没有参数

    返回值:没有返回值

    代码示例:

    x = (9,8,7,2,5,4,3)
    x.reverse()
    print(x)#注意,是反向排列,不是按照大小排序

    函数名:enumerate()

    语法:

    enumerate(sequence)

    参数:参数为可迭代对象

    返回值:返回 enumerate(枚举) 对象

    代码示例:

    seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    
    print(list(enumerate(seasons)))

    函数名:input()

    语法:

    input()

    参数:参数无

    返回值:返回输入值的类型(3 .x里 input() 默认接收到的是str 类型)

    代码示例:


    函数名:print()

    语法:

    print(*objects, sep=' ', end='\n', file=sys.stdout)

    参数:objects 为输出对象,可为多个,用,分隔; sep为间隔符,默认为" "; end为结尾的符号。默认是换行符"\n";file为要写入的文件对象

    返回值:无

    代码示例:

    print("111","222","333",sep ="===",end = "")

    函数名:open()

    语法:

    open(name, mode, buffering)

    参数:name为要访问的文件或者创建的文件的字符串,可以包含路径,model为打开文件的模式,buffering : 缓冲区大小,设为0不会有寄存,设为1表示寄存行,大于1的整数,表示寄存去缓冲区的大小,

    设置为负数,则为系统默认大小,文件打开模式如下

     

    复制代码
    r    #以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
    rb   #以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
    r+   #打开一个文件用于读写。文件指针将会放在文件的开头。
    rb+  #以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
    w    #打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    wb   #以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    w+   #打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    wb+  #以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    a    #打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    ab   #以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    a+   #打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
    ab+  #以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。
    复制代码

    返回值:file对象

    代码示例:

    f = open('test.txt')

    函数名:file()

    语法:同open()

    参数:同open()

    返回值:同open()

    代码示例:

    file('test.txt')

    函数名:raw_input()

    语法:

    raw_input(x)

    参数:x为String,可不写,会在控制台输出x内容

    返回值:返回输入的内容

    代码示例:

    raw_input_A = raw_input("raw_input:")

    函数名:iter()

    语法:

    iter(x)

    参数:x为支持迭代的集合对象

    返回值:迭代器对象

    代码示例:

    lst = [1, 2, 3]
    for i in iter(lst):
         print(i)

    函数名:range()

    语法:

    range(start, stop, step)

    参数:start为计数开始点,默认为0;stop为计数结束点,但不包括stop;step,步长,默认为1

    返回值:列表对象

    代码示例:

    range(10)
    range(1,5)
    range(1,10,2)

    函数名:dict()

    语法:

    参数:

    返回值:字典对象

    代码示例:

    复制代码
    a = dict()                        # 创建空字典
    print(a)
    a =  dict(a='a', b='b', t='t')     # 传入关键字
    print(a)
    a =  dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
    print(a)
    a =  dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
    print(a)
    复制代码

    函数名:exec()

    语法:

    exec x

    参数:x为可执行的字符串代码

    返回值:无

    代码示例:

    exec "print 'runoob.com'"

    函数名:bytearray()

    语法:

    bytearray(source, encoding, errors)

    参数:source 可以是整数、字符串、可迭代对象

    返回值:字节数数组

    代码示例:

    bytearray([1,2,3])

    函数名:complex()

    语法:

    complex(real, imag)

    参数:real 可以是 int, long, float或字符串,image可以是 int,long,float

    返回值:返回一个复数

    代码示例:

    complex(1, 2)

    函数名:xrange()

    语法:

    xrange(start, stop, step)

    参数:start开始数,stop结束数,step步长

    返回值:返回生成器

    代码示例:

    xrange(8)

    函数名:id()

    语法:

    id(object)

    参数:object为对象

    返回值:对象的内存地址

    代码示例:

    a = 'test'
    print(id(a))

    函数名:getattr()

    语法:

    getattr(object, name, default)

    参数:object为对象,那么为属性名,default为默认值,如果属性不存在,返回默认值

    返回值:属性值

    代码示例:

    getattr(a, 'bar2', 3)

    函数名:help()

    语法:

    help(x)

    参数:x为对象

    返回值:返回对象的帮助信息

    代码示例:

    help('sys')             # 查看 sys 模块的帮助

    函数名:next()

    语法:

    next(a, default)

    参数:a为可迭代对象,default为没有下一个元素时返回的值

    返回值:可迭代对象的内容

    代码示例:

    复制代码
    # 首先获得Iterator对象:
    it = iter([1, 2, 3, 4, 5])
    # 循环:
    while True:
        try:
            # 获得下一个值:
            x = next(it)
            print(x)
        except StopIteration:
            # 遇到StopIteration就退出循环
            break
    复制代码

    函数名:memoryview()

    语法:

    memoryview(obj)

    参数:obj为对象

    返回值:返回元组列表

    代码示例:

    a = memoryview(b'babcefg')
    print(a[1])

    函数名:hash()

    语法:

    hash(x)

    参数:x 为对象

    返回值: 返回对象的hash值

    代码示例:

    a = hash('test')
    print(a)

    函数名:vars()

    语法:

    vars(obj)

    参数:obj为对象,如果没有的话,返回当前调用位置的属性和属性值

    返回值:返回对象属性和属性值的字典对象

    class Runoob:
         a = 1
    
    print(vars(Runoob))

    代码示例:


    函数名:globals()

    语法:

    globals()

    参数:无

    返回值:当前位置的全局变量

    代码示例:

    print(globals())

    函数名:max()

    语法

    max(a,b,x.....)

    参数:数值表达式

    返回值:返回参数最大值

    代码示例:

    print(max(80, 100, 1000))

    函数名:property()

    语法:

    class property(fget, fset, fdel, doc)

    参数:

    • fget -- 获取属性值的函数
    • fset -- 设置属性值的函数
    • fdel -- 删除属性值函数
    • doc -- 属性描述信息

    返回值:返回类属性

    代码示例:


    函数名:ord()

    语法:

    ord(c)

    参数:c为字符

    返回值:对应的十进制数

    代码示例:

    ord('a')

    函数名:abs()

    语法:

    abs( x )

    参数:x为数值表达式

    返回值:x的绝对值

    代码示例:

    abs( -8 )

    函数名:staticmethod()

    语法:

    staticmethod(function)

    参数:无

    返回值:无

    代码示例:

    复制代码
    class C(object):
        @staticmethod
        def f():
            print('runoob');
     
    C.f();          # 静态方法无需实例化
    cobj = C()
    cobj.f()        # 也可以实例化后调用
    复制代码

    函数名:frozenset()

    语法:

    frozenset([iterable])

    参数:可迭代对象

    返回值:一个冻结的集合,不能修改或者删除

    代码示例:

    frozenset(range(10)) 

    函数名:locals()

    语法:

    locals()

    参数:无

    返回值:返回当前位置的所有局部变量

    代码示例:

    locals()

    函数名:unichr()

    语法:

    1
    unichr(i)

    参数:十进制或者十六进制的数字

    返回值:unicode 的字符。

    代码示例:

    unichr(97)

    函数名:map()

    语法:

    map(function, iterable, ...)

    参数:

    • function -- 函数,有两个参数
    • iterable -- 一个或多个序列

    返回值:返回列表

    代码示例:

    def square(x) :            # 计算平方数
         return x ** 2
     
    a = map(square, [1,2,3,4,5])

    函数名:dir()

    语法:

    dir([object])

    参数:对象

    返回值:返回属性列表

    代码示例:


    函数名:issubclass()

    语法:

    issubclass(class, classinfo)

    参数:

    class--class类, classinfo---classifo类

    返回值:如果 class 是 classinfo 的子类返回 True,否则返回 False。

    代码示例:

    class A:
        pass
    class B(A):
        pass
        
    print(issubclass(B,A))    # 返回 True

    函数名:hasattr()

    语法:

    hasattr(object, name)

    参数:object为对象,那么为属性名

    返回值:如果对象内有这个属性,返回true,否则false、

    代码示例:

    复制代码
    class Coordinate:
        x = 10
        y = -5
        z = 0
     
    point1 = Coordinate() 
    print(hasattr(point1, 'x'))
    print(hasattr(point1, 'y'))
    print(hasattr(point1, 'z'))
    print(hasattr(point1, 'no'))  # 没有该属性
    复制代码

    函数名:isinstance()

    语法:

    isinstance(object, classinfo)

    参数:

    • object -- 实例对象。
    • classinfo -- 可以是直接或间接类名、基本类型或者有它们

    返回值:如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False。。

    代码示例:

    复制代码
    class A:
        pass
     
    class B(A):
        pass
     
    isinstance(A(), A)    # returns True
    type(A()) == A        # returns True
    isinstance(B(), A)    # returns True
    type(B()) == A        # returns False
    复制代码

    函数名:any()

    语法:

    any(iterable)

    参数:元组或者列表

    返回值:如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true。

    代码示例:

    1
    any(['a''b''c''d'])  # 列表list,元素都不为空或0

    函数名:all()

    语法:

    all(iterable)

    参数:元组或列表

    返回值:如果iterable的所有元素不为0、''、False或者iterable为空,all(iterable)返回True,否则返回False;

    代码示例:

    all(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0

    函数名:callable()

    语法:

    callable(object)

    参数:对象

    返回值:可调用返回 True,否则返回 False。

    代码示例:callable(0)


    函数名:cmp()

    语法:

    参数:

    返回值:

    代码示例:


    函数名:delattr()

    语法:

    cmp( x, y )

    参数:都是数值表达式

    返回值:如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

    代码示例:

    cmp(80, 100)

    函数名:setattr()

    语法:

    setattr(object, name, value)

    参数:

    • object -- 对象。
    • name -- 字符串,对象属性。
    • value -- 属性值。

    返回值:无

    代码示例:

    复制代码
    class A(object):
         bar = 1
         
    a = A()
    getattr(a, 'bar')          # 获取属性 bar 值
    
    setattr(a, 'bar', 5)       # 设置属性 bar 值
    a.bar
    复制代码

    函数名:slice()

    语法:

    slice(start, stop, step)

    参数:

    • start -- 起始位置
    • stop -- 结束位置
    • step -- 间距

     

    返回值:一个切片对象

    代码示例:

    slice(5)

    函数名:repr()

    语法:

    repr(object)

    参数:对象

    返回值:对象的String格式

    代码示例:

    s = 'RUNOOB'
    repr(s)

    函数名:compile()

    语法:

    compile(source, filename, mode, flags, dont_inherit)

    参数:

    • source -- 字符串或者AST(Abstract Syntax Trees)对象。。
    • filename -- 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
    • mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
    • flags -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。。
    • flags和dont_inherit是用来控制编译源码时的标志

    返回值:

    代码示例:


    函数名:eval()

    语法:

    eval(expression, globals, locals)

    参数:

    • expression -- 表达式。
    • globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
    • locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。

    返回值:表达式执行结果

    代码示例:

    eval( '3 * x' )

    函数名:execfile()

    语法:

    execfile(filename, globals, locals)

    参数:

    • filename -- 文件名。
    • globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
    • locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。

    返回值:执行结果

    代码示例:

    execfile('hello.py') #需要有hello.py

    函数名:super()

    语法:

    super(type[, object-or-type])

    参数:

    • type -- 类。
    • object-or-type -- 类,一般是 self

    返回值:无

    代码示例:

    复制代码
    class FooParent(object):
        def __init__(self):
            self.parent = 'I\'m the parent.'
            print ('Parent')
        
        def bar(self,message):
            print ("%s from Parent" % message)
     
    class FooChild(FooParent):
        def __init__(self):
            # super(FooChild,self) 首先找到 FooChild 的父类(就是类 FooParent),然后把类B的对象 FooChild 转换为类 FooParent 的对象
            super(FooChild,self).__init__()    
            print ('Child')
            
        def bar(self,message):
            super(FooChild, self).bar(message)
            print ('Child bar fuction')
            print (self.parent)
     
    if __name__ == '__main__':
        fooChild = FooChild()
        fooChild.bar('HelloWorld')
    复制代码

    函数名:reload()

    语法:

    reload(module)

    参数:模块对象

    返回值:返回模块对象

    代码示例:

    reload(sys)

    函数名:type()

    语法:

    type(name, bases, dict)

    参数:

    • name -- 类的名称。
    • bases -- 基类的元组。
    • dict -- 字典,类内定义的命名空间变量。

    返回值:一个参数返回对象类型, 三个参数,返回新的类型对象。

    代码示例:

    复制代码
    type(1)
    
    type('runoob')
    
    type([2])
    
    type({0:'zero'})
    
    x = 1          
    type( x ) == int    # 判断类型是否相等
    print(x)
    # 三个参数
    class X(object):
          a = 1
    X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
    print(X)
    复制代码

    函数名:format()

    语法:String.format()

    参数:

    返回值:格式化之后的字符串

    代码示例:

    复制代码
    "{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
    "{0} {1}".format("hello", "world")  # 设置指定位置
    "{1} {0} {1}".format("hello", "world")  # 设置指定位置
    
    # 通过字典设置参数
    site = {"name": "菜鸟教程", "url": "www.runoob.com"}
    print("网站名:{name}, 地址 {url}".format(**site))
    
    my_list = ['菜鸟教程', 'www.runoob.com']
    print("网站名:{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是可选的
    
    class AssignValue(object):
        def __init__(self, value):
            self.value = value
    my_value = AssignValue(6)
    print('value 为: {0.value}'.format(my_value))  # "0" 是可选的
    复制代码

    函数名:basestring()

    语法:

    basestring()

    参数:无

    返回值:无

    代码示例:

    isinstance("Hello world", basestring)#判断一个对象是否为 str 或者 unicode 的实例

    函数名:classmethod()

    语法:

    classmethod

    参数:无

    返回值:返回函数的类方法

    代码示例:

    复制代码
    class A(object):
        bar = 1
        def func1(self):  
            print ('foo') 
        @classmethod
        def func2(cls):
            print ('func2')
            print (cls.bar)
            cls().func1()   # 调用 foo 方法
     
    A.func2()               # 不需要实例化
    复制代码

    函数名:chr()

    语法:

    chr(i)

    参数:十进制或者十六进制的数字,0-255之间

    返回值:对应的ASCLL字符

    代码示例:

    chr(123)

    函数名:__import__()

    语法:

    __import__(name)

    参数:模块名

    返回值:元组数组

    代码示例:

    import sys  
    __import__('a')        # 导入 a.py 模块

    函数名:reduce()

    语法:

    reduce(function, iterable, initializer)

    参数:

    • function -- 函数,有两个参数
    • iterable -- 可迭代对象
    • initializer -- 可选,初始参数

    返回值:返回计算结果

    代码示例:

    def add(x, y) :            # 两数相加
        return x + y
     
    reduce(add, [1,2,3,4,5])   # 计算列表和:1+2+3+4+5
    
    reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数

     

    转载于:https://www.cnblogs.com/insane-Mr-Li/p/9694329.html

    展开全文
  • Python 常用内置函数如下:1. abs()函数返回数字的绝对值。print( abs(-45) )# 返回45print("abs(0.2):",abs(0.2))#返回 abs(0.2): 0.22. all() 函数用于判断给定的参数中的所有元素是否都为 TRUE,如果是...
  • 主要介绍了Python常用内置函数总结,本文罗列了数学相关、功能相关、类型转换、字符串处理、序列处理函数等常用内置函数,需要的朋友可以参考下
  • 一、函数递归递归:函数A调用函数A递归的核心:递进的时候能够达到一个结果,问题规模越来越小(不一定要真正的达到);设置一个条件,能够让最后异次函数调用结束。递归更多的是一种思想,用来解决某种问题def age_...
  • 数学运算函数:返回数字的绝对值计算两个数的商和余数,用元组返回返回 xy(x的y次方) 的值求和计算。返回一个整数 int 或者长整数 long int 的二进制表示将一个整数转换成8进制字符串。返回浮点数x的四舍五入值。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,023
精华内容 1,609
关键字:

python常用内置函数

python 订阅