精华内容
下载资源
问答
  • python内置函数大全

    2019-01-14 19:13:34
    python内置函数大全
  • python 内置函数大全

    2019-09-03 23:20:30
    本文对python内置函数做了简单的介绍,如有错误和不足,还望指正。

    文章目录


    本文粗略的介绍了python 3 的内置函数,如有错误和不足,还望指正。

    A

    1.abs(x)

    参数–x:数值表达式,可以是整形,浮点型,复数。
    返回值:返回数值(x)的绝对值,如果(x)是复数则返回复数的大小。
    示例:

    >>> abs(-1)
    1
    >>> abs(-1.0100)
    1.01
    >>> abs(2.000)
    2.0
    >>> abs(1+1j)
    1.4142135623730951
    

    当参数为浮点形时会保留实际长度,多余的0会被省略。
    此外math模块中的fabs()函数也有类似的功能,但是fabs()的参数不能是复数。
    示例:

    >>> import math
    >>> math.fabs(1+1j)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: can't convert complex to float
    >>>
    

    2.all(iterable)

    参数:iterable::可迭代对象。
    返回值:如果iterable的所有元素不为0、’’、False或者iterable为空,all(iterable)返回True,否则返回False。
    示例:

    >>> t = ['k', 'o', '']
    >>> all(t)
    False
    >>> s = [1, 0, 1]
    >>> all(s)
    False
    >>> l = ["False", 2, "1"]   #这里False是字符串
    >>> all(l)
    True
    >>> l = [False, 1, 3]
    >>> all(l)
    False
    

    注意:空集合,空列表,空元组会返回True
    示例:

    >>> all([])
    True
    >>> all({})
    True
    >>> all(())
    True
    

    3.any(iterable)

    参数–iterable:可迭代对象。
    返回值:any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。
    大部分情况与all()函数结果相反。

    >>> any({})
    False
    >>> any([])
    False
    >>> any(())
    False
    >>> t = {1, 0, 2}
    >>> any(t)
    True
    >>> q = ["False", 1, 2]    #与all()结果相同
    >>> any(q)
    True
    

    4.ascii(object)

    参数–object:对象
    返回值:返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。
    示例:

    >>> ascii(2)
    '2'
    >>> ascii(1.00)   #当末尾有多个0时, 只会保存一个
    '1.0'
    >>> ascii("中国")
    "'\\u4e2d\\u56fd'"
    

    B

    5.bin(x)

    参数–x:int或者long int
    返回值:x的二进制表达
    示例:

    >>> bin(10)
    '0b1010'
    >>> bin(256)
    '0b100000000'
    >>> bin(-10)
    '-0b1010'
    

    6.bool([object])

    参数–object:要转化的对象
    返回值:True 或者 False。当参数为 0,’’,或者为其他数据类型却为空时返回False,当参数为空时返回False。
    示例:

    >>> t = {}
    >>> bool(t)
    False
    >>> t = []
    >>> bool(t)
    False
    >>> bool(0)
    False
    >>> bool(-1)
    True
    >>> bool("")
    False
    >>> bool()
    False
    

    7.bytearray([source, [encoding, [errors]]])

    参数–source:要转化的对象
    encoding:字符串的编码格式
    errors:默认值为"strict"(???)
    返回值:根据参数的不同,有不同的返回值。返回值为字符数组,数组元素可变。
    a.当source为空时,返回长度为0的字符数组
    b.当source为字符串时,必须要给encode参数赋值。返回经过encode
    编码的字符数组。
    c.当source为int时,返回长度为source的空数组。
    d.当source为缓冲区的对象时,会用只读的方式将对象按字节读取到字符数组后返回。
    e.当source为可迭代对象时,则此对象的元素必须属于集合[0,256),以便初始化到字符数组。
    应用技巧
    示例:

    >>> bytearray()   #参数为空
    bytearray(b'')
    
    >>> bytearray(10)           #整数
    bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
    
    >>> bytearray("中文",'utf-8')   #字符串
    bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
    
    >>> bytearray([1,0,1,1,1,0,1])    #可迭代对象
    bytearray(b'\x01\x00\x01\x01\x01\x00\x01')
    
    >>> bytearray([1.2, 2])            #可迭代对象的元素必须是整数
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'float' object cannot be interpreted as an integer
    
    >>> bytearray([1,256,2])          #可迭代对象的元素必须是range(0,256)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: byte must be in range(0, 256)
    

    8.bytes([source, [encoding, [errors]]])

    参数–source:要转化的对象
    encode:字符串的编码格式
    errors:默认值为"strict"
    返回值:根据参数的不同,有不同的返回值。返回值为字符数组,数组元素不可变,是betyarray的不可变版本。返回值与bytearray()类似。
    a.当source为空时,返回长度为0的字符数组
    b.当source为字符串时,必须要给encode参数赋值。返回经过encode
    编码的字符数组。
    c.当source为int时,返回长度为source的空数组。
    d.当source为缓冲区的对象时,会用只读的方式将对象按字节读取到字符数组后返回。
    e.当source为可迭代对象时,则此对象的元素必须属于集合[0,256),以便初始化到字符数组。
    示例:

    >>> bytes(10)
    b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
    >>> bytes("中文",'utf-8')
    b'\xe4\xb8\xad\xe6\x96\x87'
    

    C

    9.callable(object)

    参数–object:对象
    返回值:可调用返回True,不可调用返回False。callable() 函数用于检查一个对象是否是可调用的。如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。
    对于函数、方法、lambda 函式、 类以及实现了 _ call _ 方法的类实例, 它都返回 True。
    示例:

    >>> callable(10)    #常数
    False
    >>> def add():     #方法
    ...     print("11")
    ...
    >>> callable(add)
    True
    >>> class A():    #类, 没有实现__call__()方法
    ...     def __init__(self):
    ...             x = 10
    ...
    >>> callable(A)
    True
    >>> a = A()     #类实例
    >>> callable(a)
    False
    >>> class B():       #类,实现__call__()方法
    ...     def __call__(self):
    ...             return 0
    >>> callable(B)
    True
    >>> b = B()
    >>> callable(b)
    True
    >>>
    

    10.chr(x)

    参数–x:10进制或者16进制的整数,x>=0。
    返回值:返回对应的ascii码字符。
    示例:

    >>> chr(0)
    '\x00'
    >>> chr(1)
    '\x01'
    >>> chr(52)
    '4'
    >>> chr(97)
    'a'
    >>> chr(10000)
    '✐'
    >>> chr(-1)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: chr() arg not in range(0x110000)
    

    11.classmethod()
    描述:装饰器的一种与@联用。返回一个经过装饰器装饰的函数。classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。
    参数:无
    返回值:返回函数的类方法。
    参考112479的博客
    示例:

    class A():
        q = 10
        def __init__(self, s):
            print(s)
    
        @classmethod
        def testmethod(cls):
            print(cls.q)        #经@classmethod修饰,可直接使用类的属性
            return cls(123)
    
    t = A.testmethod()  #经@classmethod修饰可不初始化直接调用
    

    执行结果:

    10
    123
    

    这里的执行顺序是A ->testmethod -> _ init _
    另外 cls是个位置参数,可更换为其他名称,如 this。
    示例:

    class A():
        q = 10
        def __init__(self, s):
            print(s)
    
        @classmethod
        def testmethod(this):
            print(this.q)
            return this(123)
    
    t = A.testmethod()
    

    执行结果:

    10
    123
    

    12.compile(source,filename, mode[, flags, [dont_inherit,optimize = -1]])

    描述:将字符串编译成字节代码。
    参数–source:字符串或AST对象。
    filename:需要的是代码读取的文件名;如果代码不需要从文件中读取,可以传入一些可辨识的值(经常会使用 ‘<string>’)
    mode:mode 实参指定了编译代码必须用的模式。如果 source 是语句序列,可以是 ‘exec’;如果是单一表达式,可以是 ‘eval’;如果是单个交互式语句,可以是 ‘single’。(在最后一种情况下,如果表达式执行结果不是 None 将会被打印出来。)
    flags和dont_inherit是用来控制编译源码时的标志
    optimize:optimize 实参指定编译器的优化级别;默认值 -1 选择与解释器的 -O 选项相同的优化级别。显式级别为 0 (没有优化;debug 为真)、1 (断言被删除, debug 为假)或 2 (文档字符串也被删除)。
    示例:

    >>> str = "for i in range(10): print(i)"
    >>> c = compile(str, "", "exec")
    >>> c
    <code object <module> at 0x0000029C7FA48030, file "", line 1>
    >>> exec(c)
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> str = "3 + 5 * 4"
    >>> d = compile(str, "", "eval")
    >>> eval(d)
    23
    >>> exec(d)   #不是指定的mode,不能得出结果。
    

    如果是单一表达式,只能是eval;使用exec不会报错但得不到结果。
    在 ‘single’ 或 ‘eval’ 模式编译多行代码字符串时,输入必须以至少一个换行符结尾。 这使 code 模块更容易检测语句的完整性。

    13.complex([real [,imag])

    描述:将字符串或数字转换为复数。
    参数–real:实数部分,可以是int,也可以是string
    image:虚数部分
    如果第一个形参是字符串,则它被解释为一个复数,并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型(包括复数)。如果省略了 imag,则默认值为零,构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略,则返回 0j。
    返回值:返回一个 大小为 real + imag * j 的复数

    注意:从字符串转换时,字符串在 + 或 - 的周围必须不能有空格。例如 complex(‘1+2j’) 是合法的,但 complex(‘1 + 2j’) 会触发 ValueError 异常。
    示例:

    >>> complex(1)
    (1+0j)
    >>> complex(1, -1)
    (1-1j)
    
    >>> complex("1", -1)     #当第一个参数为字符串,不能有第二个参数
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: complex() can't take second arg if first is a string
    
    >>> complex(1+1j, -1)   #参数可以是复数
    (1+0j)
    >>> complex("1+1j")
    (1+1j)
    
    >>> complex("1 + 1j")   #注意 ‘+’ / ‘-’ 周围不能有空格
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: complex() arg is a malformed string
    

    D

    14.delattr(object,name)

    描述:删除一个对象的某个属性。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许,该函数将删除指定的属性。例如 delattr(x, ‘foobar’) 等价于 del x.foobar 。

    参数–object:对象
    name:该对象的某个属性名称,是个字符串s。
    返回值:无
    示例:

    class test():
        a = 1
        b = 2
    
    t = test()
    print(t.a)
    print(t.b)
    delattr(test, "b")
    print(t.a)
    print(t.b)
    

    执行结果:

    1
    2
    1
    Traceback (most recent call last):
      File "c:/Users/hasee/Desktop/111-1.py", line 74, in <module>
        print(t.b)
    AttributeError: 'test' object has no attribute 'b'
    
    

    15.dict()

    描述:创建一个新的字典。共有三种形式dict(**kwarg),dict(mapping,**kwarg),dict(iterable,**kwarg)
    参数–**kwarg:关键字
    mapping:元素的容器
    iterable:可迭代的对象
    示例:

    #五种字典初始化方法
    >>> dict1 = {}
    >>> dict1['firstname'] = 'ma'
    >>> dict1['lastname'] = 'yun'
    >>>
    >>> dict1 = {'firstname':'ma', 'lastname':'yun'}
    >>>
    >>> dict1 = dict([('firstname','ma'), ('lastname', 'yun')])
    >>>
    >>> dict1 = dict(firstname = 'ma', lastname = 'yun')
    >>>
    >>> dict1 = dict(zip(['firstname', 'lastname'], ['ma', 'yun']))
    

    16.dir(object)

    描述:如果没有实参,则返回当前本地作用域中的名称列表。如果有实参,它会尝试返回该对象的有效属性列表。
    参数–object:对象,类型,变量
    示例:

    >>>dir()   #  获得当前模块的属性列表
    ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
    >>> dir([ ])    # 查看列表的方法
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    

    17.divmod(a,b)

    描述:divmod() 函数接收两个数字类型(非复数)参数,返回一个包含商和余数的元组(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 非零,它的符号和 b 一样,并且 0 <= abs(a % b) < abs(b) 。
    示例:

    >>> divmod(3,2)
    (1, 1)
    >>> divmod(-3,2)
    (-2, 1)
    >>> divmod(3,-2)       #当余数不为0时,余数的符号与 b 相同
    (-2, -1)
    >>> divmod(3.2,2)
    (1.0, 1.2000000000000002)
    >>> divmod(3.3,3)                  
    (1.0, 0.2999999999999998)    #当是浮点数时,结果是近似
    >>> divmod(3.3,4)
    (0.0, 3.3)
    

    E

    18.enumerate(iterable,start = 0)

    描述:接收一个元组,返回一个枚举对象。
    参数–iterable:一个序列、迭代器或其他支持迭代对象。
    start:序号的起始,默认为0。
    返回值:返回一个枚举对象。
    示例:

    >>> for i in enumerate(a):
    ...     print(i)
    ...
    (0, 'a')
    (1, 'b')
    (2, 'c')
    #对于字典,会枚举输出关键字
    >>> d = dict(firstname = "zhong",lastname = "guo")
    >>> for i in enumerate(d):
    ...     print(i)
    ...
    (0, 'firstname')
    (1, 'lastname')
    

    19.eval(expression, globals=None, locals=None)

    描述:接收一个字符串表达式,返回其计算结果。
    参数–expression:字符串表达式
    globals – 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
    locals – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
    返回值:表达式的计算结果。
    示例:

    >>> eval("3 + 4 > 10")
    False
    >>> x = 2
    >>> eval("3*x")
    6
    >>> d = dict(x = 7, y = 8, z = 9)
    >>> eval("y + z", "", d)      #globals 不能为 ""
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: globals must be a real dict; try eval(expr, {}, mapping)
    >>> c = {}
    >>> eval("y+z", c, d)
    17
    >>> eval("y+z", d)  
    17
    

    小技巧:
    A.eval()可以去掉字符串的引号,返回字符串本身
    示例:

    >>> a = "123"
    >>> eval(a)
    123
    

    B.可以用来直接读取用户输入的多个数据

    >>> a, b = input()   #直接input()不能同时输入多个数据
    10,5
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: too many values to unpack (expected 2)
    
    >>> a, b = eval(input())   
    10,5
    >>> print(a,b)
    10 5
    

    20.exec(object[, globals[, locals]])

    描述:exec 执行储存在字符串或文件中的 Python 语句,相比于 eval,exec可以执行更复杂的 Python 代码。
    参数–object:必选参数,表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串,该字符串会先被解析为一组Python语句,然后在执行(除非发生语法错误)。如果object是一个code对象,那么它只是被简单的执行。
    globals:可选参数,表示全局命名空间(存放全局变量),如果被提供,则必须是一个字典对象。
    locals:可选参数,表示当前局部命名空间(存放局部变量),如果被提供,可以是任何映射对象。如果该参数被忽略,那么它将会取与globals相同的值。
    返回值:None
    示例:

    x = 10
    y = 10
    expr = """
    z = 30
    sum = x + y + z
    print(sum)
    """
    def func():
        y = 20
        exec(expr)  # 默认使用最近的参数  计算过程为 30 + 20 +10
        exec(expr, {'x': 1, 'y': 2})   #计算过程为  30 + 1 + 2
        exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})  # 外部参数不能替代原本字符串里面的值,且当globals与locals有相同参数时优先使用locals的
        
    func()
    

    执行结果:

    60
    33
    34
    

    F

    21.filter(function,iterable)

    描述:根据function对iterable进行筛选,符合条件的留下,不符合的剔除,构建新的迭代器。
    参数–function:判断函数。
    iterable:可迭代对象。
    返回值:新的可迭代对象。
    示例:

    #选出1~100中平方根是整数的数
    import math
    def is_sqr(x):
        return math.sqrt(x) % 1 == 0
     
    tmplist = filter(is_sqr, range(1, 101))
    newlist = list(tmplist)
    print(newlist)
    

    执行结果:

    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    

    22.float([x])

    描述:将字符串或整数转化为浮点型。
    参数–x:字符串或者整数。如果实参是字符串,则它必须是包含十进制数字的字符串,字符串前面可以有符号,之前也可以有空格。可选的符号有 ‘+’ 和 ‘-’ ; ‘+’ 对创建的值没有影响。实参也可以是 NaN(非数字)、正负无穷大的字符串。确切地说,除去首尾的空格后,输入必须遵循以下语法:

    sign “+” | “-”
    infinity “Infinity” | “inf”
    nan “nan”
    numeric_value floatnumber | infinity | nan
    numeric_string [sign] numeric_value

    返回值:返回浮点数。实参为空时返回 0.0
    示例:

    >>> float("inf")
    inf
    >>> float("nan")
    nan
    >>> float("-3.14e10")
    -31400000000.0
    >>> float()
    0.0
    

    23.format(value[, format_spec]))

    描述:用于格式化输出,取代%。将 value 转换为 format_spec 控制的“格式化”表示。
    参数–value:要输出的值
    format_spec:控制value输出的格式。
    返回值:无
    示例:

    >>>"{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
    'hello world'
     
    >>> "{0} {1}".format("hello", "world")  # 设置指定位置
    'hello world'
     
    >>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
    'world hello world'
    
    >>> format(255, '#x'), format(255, 'x'), format(255, 'X')  #设置format_spec 为16进制输出
    ('0xff', 'ff', 'FF')
    
    >>> f'{255:#x}', f'{255:x}', f'{255:X}'   #简化书写
    ('0xff', 'ff', 'FF')
    

    也可以设置参数名字:

    >>> print("name = {name}, age = {age}".format(name = "china", age = 70))  #直接设置参数值
    name = china, age = 70
    
    >>> s = ["china", 70]                               #用单个列表保存实参值
    >>> print("name = {0}, age = {1}".format(*s))
    name = china, age = 70
    
    >>> t1 = ["china"]								   #用多个列表保存实参值
    >>> t2 = [70]
    >>> print("name = {0[0]}, age = {1[0]}".format(t1,t2))
    name = china, age = 70
    
    >>> t = dict(name = "china", age = 70)              #用字典保存实参值
    >>> print("name = {name}, age = {age}".format(**t))
    name = china, age = 70
    

    更多详细使用技巧参考菜鸟教程

    24.frozenset([iterable])

    描述:返回一个冻结的集合,不能再对此集合进行增删操作。
    参数–iterable: 可迭代的对象,比如列表、字典、元组等等。
    返回值:返回一个forzenset对象,该对象的元素来自于iterable。没有实参则返回一个空集合。
    示例:

    >>>a = frozenset(range(10))     # 生成一个新的不可变集合
    >>> a
    frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> b = frozenset('runoob') 
    >>> b
    frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
    

    G

    25.getattr(object, name[,default])

    描述:获得对象(object)名字为name的属性。
    参数–object:对象
    name:字符串,想要获取的属性的名字。
    default:当要获取的属性不存在时的默认返回值。如果不提供,当属性不存在时将触发 AttributeError。可以是字符串,可以是数字类型,也可以是函数。可以认为是异常处理手段。
    返回值:返回对应属性的值。
    示例:

    >>> class A():
    ...     x = 10
    ...     y = 15
    ...
    >>>
    >>> getattr(A,"x")
    10
    >>>
    >>> getattr(A, "z", -1)
    -1
    >>>
    >>> getattr(A, "z", "无此属性")   #default 可以是字符串
    '无此属性'
    >>>
    >>> def test():       #default 可以是函数
    ...     print("111")
    ...
    >>> getattr(A, "z", test())
    111
    

    此外也可以获取方法。
    示例:

    class A():
        def set(self, a, b):
            print(a + b)
        x = 10
    
    a = A()
    c = getattr(a, "set")   #获取到对象的方法 并且可以直接使用
    c(1, 2)
    

    执行结果:

    3
    

    26.globals()----

    描述:函数会以字典类型返回当前位置的全部全局变量。
    参数:无
    返回值:返回全局变量的字典。
    示例:

    >>> class A():
    ...     x = 10
    ...
    >>>
    >>> print(globals())
    {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__':
    {}, '__builtins__': <module 'builtins' (built-in)>, 'A': <class '__main__.A'>}
    

    H

    27.hasattr(object,name)

    描述:用于判断对象是否包含对应的属性。
    参数–object:对象。
    name:属性名称,字符串。
    返回值:如果对象有该属性返回 True,否则返回 False。
    示例:

    class A():
        def set(self, a, b):
            print(a + b)
        x = 10
    
    print(hasattr(A, "set"))
    print(hasattr(A, "x"))
    
    

    执行结果:

    True
    True
    

    28.hash(object)

    描述:返回该对象的哈希值(如果它有的话)。
    参数–object:对象。一般是整型,浮点型,字符串。不能直接是list,set,dictionary。
    返回值:对象的hash值。
    示例:

    >>> hash("qwer")
    3620707056588834181
    
    >>> hash("qwrerthlfbkncndfjoidddviofj")
    -3805363231758489070
    
    >>> hash("qwrerthlfbkncndfjoidddviofj")
    -3805363231758489070
    

    可以看出同一个值的hash值相同,可以利用这一点来校验字符串是否被第三方篡改。

    29.help([object])

    描述:用于查看函数或模块用途的详细说明。
    参数–object:对象。
    返回值:返回对象帮助信息。
    示例:

    >>> import math
    >>> help(math)   #查询模块信息
    Help on built-in module math:
    
    NAME
        math
    
    DESCRIPTION
        This module is always available.  It provides access to the
        mathematical functions defined by the C standard.
    ......
    
    >>> help(math.sin)  #查询函数信息
    Help on built-in function sin in module math:
    
    sin(x, /)
        Return the sine of x (measured in radians).
    

    30.hex(x)

    描述:将整数转换为以“0x”为前缀的小写十六进制字符串。
    参数–x:整数。
    返回值:小写的十六进制字符串。
    示例:

    >>> hex(16)
    '0x10'
    
    >>> "%x" %10    #用 %x 转换进制
    'a'
    
    >>> format(10,  "#x")    #用format转换进制
    '0xa'
    
    >>> f'{255:#x}', f'{255:x}', f'{255:X}'  
    ('0xff', 'ff', 'FF')
    

    I

    31.id(object)

    描述:返回对象在内存中的地址。
    参数–object:对象。
    返回值:对象在内存中的地址。
    示例:

    >>> a = "china"
    >>> id(a)
    1739113113224
    >>> b = 10
    >>> id(b)
    140733210059696
    

    32.input([prompt])

    描述:Python3.x 中 input() 函数接受一个标准输入数据,返回为 string 类型。在 Python3.x 中 raw_input() 和 input() 进行了整合,去除了 raw_input( ),仅保留了input( )函数,其接收任意任性输入,将所有输入默认为字符串处理,并返回字符串类型。
    参数–prompt:提示信息
    返回值:以字符串形式返回输入的内容。
    示例:

    >>> num = input()
    10
    >>> num
    '10'
    >>> temp = input("请输入数字temp:")
    请输入数字temp:10
    >>> temp
    '10'
    

    33.int(x, base = 10)

    描述:用于将一个字符串或数字转换为整型。
    参数--x:字符串或数字。如果 x 不是数字,或者有 base 参数,x 必须是字符串、bytes、表示进制为 base 的 整数字面值 的 bytearray 实例。该文字前可以有 + 或 - (中间不能有空格),前后可以有空格。
    返回值:返回10进制整型数据。
    示例:

    >>> int()
    0
    >>> int("123", 10) 
    123
    >>> int("123", 16)    #当有base = 8时,表示123为八进制数
    291
    >>> int("123", 8)  
    83
    

    34.isinstance(object,classinfo)

    描述:isinstance() 函数来判断一个对象是否是一个已知的类型的实例,类似 type()。
    参数–object:实例对象。
    classinfo:可以是直接或间接类名、基本类型或者由它们组成的元组。
    返回值:如果 object 实参是 classinfo 实参的实例,或者是(直接、间接或 虚拟)子类的实例,则返回 true。如果 object 不是给定类型的对象,函数始终返回 false。如果 classinfo 是对象类型(或多个递归元组)的元组,如果 object 是其中的任何一个的实例则返回 true。 如果 classinfo 既不是类型,也不是类型元组或类型的递归元组,那么会触发 TypeError 异常。
    示例:

    >>>a = 2
    >>> isinstance (a,int)
    True
    >>> isinstance (a,str)
    False
    >>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
    True
    

    isinstance()与type()的区别:

    class A:
        pass
     
    class B(A):
        pass
     
    print(isinstance(A(), A) )   # returns True
    print(type(A()) == A)        # returns True
    print(isinstance(B(), A))  # returns True
    print(type(B()) == A )       # returns False
    

    执行结果:

    True
    True
    True
    False
    

    从上可以看出type()不能识别出子类。
    此外注意在classinfo中字符串是 str 不是string,字典是 dict
    示例:

    >>> a = 123
    >>> isinstance(a, str)
    False
    
    >>> isinstance(a, string)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'string' is not defined
    

    35.issubclass(class, classinfo)

    描述:用于判断参数 class 是否是类型参数 classinfo 的子类。方法与isinstance()类似。
    参数–class :子类。
    classinfo :父类。
    返回值:如果 class 是 classinfo 的子类(直接、间接或 虚拟 的),则返回 true。classinfo 可以是类对象的元组,此时 classinfo 中的每个元素都会被检查。其他情况,会触发 TypeError 异常。
    示例:

    class A:
        pass
     
    class B(A):
        pass
    
    print(issubclass(B, A))
    

    执行结果:

    True
    

    36.iter(object[, sentinel])----

    描述:iter() 函数用来生成迭代器。
    参数–object: 支持迭代的集合对象。
    sentinel:如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object。可以认为是一个终止符。
    返回值:迭代器对象。
    示例:

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

    详细使用可参考一只小小寄居蟹的博客

    37.len(s)

    描述:返回对象中元素的个数。
    参数–s:可以是序列(如 string、bytes、tuple、list 或 range 等)或集合(如 dictionary、set 或 frozen set 等)。
    返回值:对象s中元素的个数。
    示例:

    >>> str = "abcdefg"
    >>> len(str)
    7
    
    >>> e = {1, 2, 3, 4, 5}
    >>> len(e)
    5
    

    38.list([iterable])

    描述:用于将元组或字符串转换为列表。
    参数–iterable:要转换为列表的元组或字符串。
    返回值:返回一个列表。
    示例:

    >>> tuple = {1, "a", 32, "cd" }
    >>> temp = list(tuple)    #将元组转换成了列表,可以再次对其进行修改
    >>> temp.append(4)
    >>> temp
    [32, 1, 'cd', 'a', 4]
    

    39.locals()

    描述:更新并返回表示当前本地符号表的字典。
    参数:无
    返回值:更新并返回表示当前本地符号表的字典。
    示例:

    class A():
        x = 10
        def test(self, a, b):
            y = 20
            print(locals())      #locals的范围小,当在方法中使用时指方法的全局变量
    
    print(globals())        #globals范围大,一般指模块内的全局变量
    a = A()
    a.test(1, 2)
    

    执行结果:

    {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000025803BBEEF0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'c:/Users/hasee/Desktop/111-1.py', '__cached__': None, 'A': <class '__main__.A'>}
    {'self': <__main__.A object at 0x0000025805821438>, 'a': 1, 'b': 2, 'y': 20}
    

    M

    40.map(function,iterable,…)

    描述:根据提供的函数对指定序列做映射。
    参数–function:函数。
    iterable:序列
    返回值:返回一个经过function映射的迭代器。 如果传入了额外的 iterable 参数,function 的映射操作会从每一个iterable对应位置取一个值进行计算。 当有多个可迭代对象时,最短的可迭代对象耗尽则整个迭代就将结束。
    示例:

    >>>def square(x) :            # 计算平方数
    ...     return x ** 2
    ... 
    >>> for i in map(square, [1,2,3,4,5]):# 计算列表各个元素的平方
    ...     print(i)
    
    #使用匿名函数
    >>> for i in map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10, 12]):
    ...     print(i)
    ...
    3
    7
    11
    15
    19
     
    

    与filter()的区别:filter 是通过生成 True 和 False 组成的迭代器将可迭代对象中不符合条件的元素过滤掉;而 map 返回的则是 True 和 False 组成的迭代器。

    >>> res1 = map(lambda n: n > 5, range(10))
    >>> lt1 = list(res1)
    >>> print(lt1)
    [False, False, False, False, False, False, True, True, True, True]
    
    >>> res2 = filter(lambda n: n > 5, range(10))
    >>> lt = list(res2)
    >>> print(lt) 
    [6, 7, 8, 9]
    

    41.max(iterable, *[, key, default])

    描述:获取序列中值最大的元素。还有一种写法为 max(arg1, arg2, *args[, key])
    参数–当只有一个位置参数时,必须是非空的iterable。
    iterable:列表,元组,字典等。
    key:指定排序函数用的参数
    default:当可迭代对象为空时返回的值。
    返回值:如果只提供了一个位置参数,返回可迭代对象中最小的元素;如果提供了两个及以上的位置参数,则返回最小的位置参数。如果有多个最小元素,则此函数将返回第一个找到的。
    示例:

    t1 = (2, "wang")
    t2 = (3, "zhao")
    t3 = (4, "li")
    
    print(max(t3, t2, t1, key = lambda x: x[0]))  # key 一般用关键字 + 匿名函数来表示
    

    执行结果:

    (4, 'li')
    

    42.memoryview(object)

    描述:memoryview() 函数返回给定参数的内存查看对象(Momory view)。
    所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问。
    参数–object:必须支持缓冲区协议的对象,支持缓冲区协议的内置对象包括 bytes 和 bytearray。
    返回值:返回元组列表。
    示例:

    >> a = b"aaaaa"
    >>> ma = memoryview(a)
    >>> ma.readonly   #只读memoryview
    True
    >>> mb = ma[:2]   #不会产生新的字符串
    >>> mb = "bb"
    >>> ma.tobytes()
    b'aaaaa'
    
    >>> a = bytearray('aaaa', "utf8")
    >>> ma = memoryview(a)
    >>> mb = ma[:2]
    >>> mb.readonly      #可写memoryview
    False
    >>> mb[:2] = b"bb"   #修改mb相当于修改ma,同时注意赋值方法
    >>> mb.tobytes()
    b'bb'
    >>> ma.tobytes()
    b'bbaa'
    

    详细使用技巧可参考这里

    43.min(iterable, *[, key, default])

    描述:获取序列中值最小的元素。还有一种写法为 min(arg1, arg2, *args[, key])
    参数–当只有一个位置参数时,必须是非空的iterable。
    iterable:列表,元组,字典等。
    key:指定排序函数用的参数
    default:当可迭代对象为空时返回的值。
    返回值:如果只提供了一个位置参数,返回可迭代对象中最小的元素;如果提供了两个及以上的位置参数,则返回最小的位置参数。如果有多个最小元素,则此函数将返回第一个找到的。
    示例:

    t1 = (2, "wang")
    t2 = (3, "zhao")
    t3 = (4, "li")
    
    print(min(t3, t2, t1, key = lambda x: x[0]))  # key 一般用关键字 + 匿名函数来表示
    

    执行结果:

    (2, "wang")
    

    N

    44.next(iterator[,default])

    描述:返回迭代器的下一个项目。
    参数–iterable:迭代器。
    default:用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。
    返回值:迭代器中的一个元素。当下一个元素不存在,且default不为空将返回default 的值,否则抛出StopIteration异常。
    注意:list,dict,set 都不是迭代器,不能直接使用next(),需要使用 iter() 方法将其转化为iterator
    示例:

    >>> lst = [1, 3, 4, 6]
    >>> next(lst)    #不能直接使用
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'list' object is not an iterator
    
    >>> next(iter(lst))    #用名称只能获取到第一个元素
    1
    
    >>> lst = iter(lst)  #结合循环使用时,要先转化成 iterator
    >>> while 1:
    ...     x = next(lst, "a")    #设置default
    ...     print(x)
    ...     if x == "a":
    ...             break
    ...
    1
    3
    4
    6
    a
    

    O

    45.object()

    描述:返回一个没有特征的对象。
    参数:无。
    返回值:返回一个object类的实例。object 是所有类的基类。它具有所有 Python 类实例的通用方法。
    注意:由于 object 没有 _ _dict_ _ ,因此无法将任何属性赋给 object 的实例。

    示例:

    >>> o = object()
    >>> dir(o)      #object 有所有类的公共方法
    ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__',
    '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
    
    >>> class A:
    ...     x = 10
    ...
    
    >>> issubclass(A, object)  #object 是所有类的基类
    True
    
    >>> a = A()  
    >>> a.name = "wang"   #普通类可以设置属性
    
    >>> o.name = "wang"    #object 不可以设置属性
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: 'dict' object has no attribute 'name'
    

    46.oct(x)

    描述:将一个整数变成前缀为 "0o"的进制字符串。
    参数–x:整数
    返回值:八进制的字符串。
    示例:

    >>> oct(8)
    '0o10'
    
    >>> oct(8.0)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'float' object cannot be interpreted as an integer
    

    47.open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

    描述:Python open() 函数用于打开一个文件,并返回文件对象,在对文件进行处理过程都需要使用到这个函数,如果该文件无法被打开,会抛出 OSError。
    参数–file:必需,文件路径(相对或者绝对路径)。
    mode: 可选,文件打开模式。
    buffering:设置缓冲。
    encoding: 一般使用utf8。
    errors: 是一个可选的字符串参数,用于指定如何处理编码和解码错误 - 这不能在二进制模式下使用。
    newline:设置换行符。它可以是 None,’’,’\n’,’\r’ 和 ‘\r\n’。
    closefd: 传入的file参数类型。
    opener:
    返回值:返回对应的file object,如果文件不存在,则触发OSError。
    注意:使用 open() 函数一定要保证关闭文件对象,即调用 close() 函数。使用with open() 可以自动关闭文件对象。
    open() 函数常用形式是接收两个参数:文件名(file)和模式(mode)。
    示例:

    >>> with open(r"C:\Users\hasee\Desktop\test.txt", "r") as f:
    ...     f.read()
    ...
    'Hello World!'
    

    附表1 mode的类型

    模式 描述
    t 文本模式 (默认)。
    x 写模式,新建一个文件,如果该文件已存在则会报错。
    b 二进制模式。
    + 打开一个文件进行更新(可读可写)。
    U 通用换行模式(不推荐)。
    r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
    rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
    r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
    rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
    w 打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
    w+ 打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
    a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
    ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。

    注意:1.Python区分二进制和文本I/O。以二进制模式打开的文件(包括 mode 参数中的 ‘b’ )返回的内容为 bytes 对象,不进行任何解码。在文本模式下(默认情况下,或者在 mode 参数中包含 ‘t’)时,文件内容返回为 str ,首先使用指定的 encoding (如果给定)或者使用平台默认的的字节编码解码。

    2.a 与 a+ 的区别
    a :追加写,但是不能读。
    a+:追加写,可读。但是文件指针在末尾,直接读取内容为空。

    示例:

    >>> with open(r"C:\Users\hasee\Desktop\test.txt", "a") as f:
    ...     f.read()    #  a 不能直接读取
    ...
    Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
    io.UnsupportedOperation: not readable
    
    >>> with open(r"C:\Users\hasee\Desktop\test.txt", "a+") as f:
    ...     f.read()    # a+ 直接读取内容为空 
    ...
    ''
    

    附表二 设置buffering 的含义

    数值 含义
    0 关闭缓冲,仅允许在二进制模式下
    1 选择行缓冲,仅允许在文本模式下
    >1 以指示固定大小的块缓冲区的大小(以字节为单位)

    附表三 errors 的类型

    模式 含义
    None 如果存在编码错误,会引发 ValueError 异常
    strict 如果存在编码错误,会引发 ValueError 异常
    ignore 忽略错误。请注意,忽略编码错误可能会导致数据丢失。
    replace 会将替换标记(例如 ‘?’ )插入有错误数据的地方。
    surrogateescape 将表示任何不正确的字节作为Unicode专用区中的代码点,范围从U+DC80到U+DCFF。当在写入数据时使用 surrogateescape 错误处理程序时,这些私有代码点将被转回到相同的字节中。这对于处理未知编码的文件很有用。
    xmlcharrefreplace 只有在写入文件时才支持 ‘xmlcharrefreplace’。编码不支持的字符将替换为相应的XML字符引用 &#nnn;。
    backslashreplace 用Python的反向转义序列替换格式错误的数据。
    namereplace (也只在编写时支持)用 \N{…} 转义序列替换不支持的字符。

    注:转义序列即转义字符的集合,包括 \n,\r,\t,\u 等等。

    48.ord( c )

    描述:对表示单个 Unicode 字符的字符串,返回代表它 Unicode 码点的整数。
    参数–c:单个的 Unicode 字符。
    返回值:对应的 Unicode 码点的整数。
    示例:

    >>> ord("#")
    35
    

    P

    49.pow(x,y[,z])

    描述:返回 x 的 y 次幂;如果 z 存在,则对 z 取余。
    参数–x:数值表达式
    y:数值表达式
    z:数值表达式
    返回值:返回 x 的 y 次幂;如果 z 存在,则对 z 取余。
    注意: math 模块中也包含 pow()方法,区别如下:

    区别 描述
    参数个数 math.pow() 只能有两个参数,内置的pow()可以有三个参数。
    返回值类型 math.pow()默认返回float,内置的pow()默认返回int

    示例:

    >>> import math
    >>> math.pow(10, 2, 3)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: pow() takes exactly 2 arguments (3 given)
    
    >>> math.pow(10, 2)  
    100.0
    
    >>> pow(10, 2, 3)
    1
    
    >>> pow(3*2, 2*2)
    1296
    

    50.print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

    描述:print() 方法用于打印输出,最常见的一个函数。print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字。
    参数–*objects:可以接收多个参数,中键用 ‘,’ 分隔开。
    sep:间隔符,当接收多个输出值时,两两之间用 sep 间隔开,默认为空格。
    end:结尾后缀。输出以什么结尾,默认为’\n’,可替换成其他合理值。
    file:要写入的文件对象。如果参数不存在或为 None,则将使用 sys.stdout.
    flush:当为真是,会强制刷新流。
    返回值:无。
    示例:

    >>> a = 123
    >>> b = "hello"
    >>> c = "world"
    >>> print(a, b, c, sep = "##", end = "&&")    #这里没有换行符
    123##hello##world&&>>>
    
    >>> print(a, b, c, sep = "##", end = "&&\n")
    123##hello##world&&
    
    >>> with open(r"C:\Users\hasee\Desktop\test.txt", "a+") as f:
    ...     print(a, b, c, sep = "##", file = f)
    ...
    >>> with open(r"C:\Users\hasee\Desktop\test.txt", "r") as f:
    ...     f.read()
    ...
    'Hello World!123##hello##world\n'
    >>>
    

    51.property(fget=None, fset=None, fdel=None, doc=None)

    描述:可以对属性进行封装,不直接调用属性。
    参数–fget:获取属性值的函数
    fset:设置属性值的函数
    fdel:删除属性值的函数
    doc:属性的描述信息
    返回值:返回封装好的属性。
    示例:

    class A:
        def __init__(self, value):
            self._x = value
        
        def getx(self):
            print("get self._x")
            return self._x
        
        def setx(self, value):
            print("set self._x")
            self._x = value
        
        def delx(self):
            print("del self._x")
            del self._x
    
        x = property(getx, setx, delx, "this is private _x")   #对私有属性进行封装
    
    a = A(10)
    print(a.x)
    a.x = 20
    print(a.x)
    del a.x
    print(a.x)
    

    执行结果:

    get self._x
    10
    set self._x
    get self._x
    20
    del self._x
    get self._x
    Traceback (most recent call last):
      File "c:/Users/hasee/Desktop/111-1.py", line 163, in <module>
        print(a.x)
      File "c:/Users/hasee/Desktop/111-1.py", line 146, in getx
        return self._x
    AttributeError: 'A' object has no attribute '_x'
    

    a.x 将触发 getx,a.x = value 将触发 setx , del a.x 触发 delx。
    如果给定 doc 参数,其将成为这个属性值的 docstring,否则 property 函数就会复制 fget 函数的 docstring(如果有的话)。
    注意:python 中还有 @property 装饰器,可以将方法变为属性使用。具体使用可参照Funhacks的博客

    R

    52.range(start,stop[,step])

    描述:Python3 range() 函数返回的是一个可迭代对象(类型是对象),而不是列表类型, 所以打印的时候不会打印列表。
    Python3 list() 函数是对象迭代器,可以把range()返回的可迭代对象转为一个列表,返回的变量类型为列表。
    Python2 range() 函数返回的是列表。
    参数–start:计数起始值,默认为 0 。
    stop:计数结束值,将不会输出,即range的取值范围为[start,stop)。
    step:步长。默认为1。
    返回值:返回一个序列对象range
    示例:

    >>> x = range(5)
    >>> type(x)
    <class 'range'>
    >>> for i in x:
    ...     print(i)
    ...
    0
    1
    2
    3
    4
    
    >>> for i in range(0, 10, 2):
    ...     print(i)
    ...
    0
    2
    4
    6
    8
    

    注意:当有step不为空时,start 必须不为空,否则会出现错我的结果。
    range的计算公式为 i = start + step 。所以范围为负数时要将 数值小的作为 start。同时可以将步长设为 -1 倒序遍历,此时应将start 设为大的值。
    示例:

    >>> for i in range(0, 10, -1):
    ...     print(i)
    ...
    >>>
    >>>
    >>>
    >>>
    >>>
    >>> for i in range(5, 0, -1):
    ...     print(i)
    ...
    5
    4
    3
    2
    1
    >>> for i in range(-4, -1):
    ...     print(i)
    ...
    -4
    -3
    -2
    

    53.repr(object)

    描述:将对象转化成可输出的字符串,如果给与参数时可执行的语句,则先执行,再返回结果的字符串。
    参数–object:对象。
    返回值:一个字符串对象。
    示例:

    >>> x = [1, 2, 3, 4]
    >>> repr(x)
    '[1, 2, 3, 4]'
    
    >>> a = 3
    >>> b = 4
    >>> repr((a + b))
    '7'
    

    54.reversed(seq)

    描述:将序列顺序颠倒,返回一个迭代器。
    参数–seq:要反转的序列。
    返回值:返回一个迭代器。
    示例:

    >>> x
    [1, 2, 3, 4]
    >>> x = reversed(x)
    >>> print(x)
    <list_reverseiterator object at 0x0000018E528D1CC0>
    >>> list(x)
    [4, 3, 2, 1]
    

    55.round(number[, ndigits])

    描述:对数字进行四舍五入计算。返回 number 舍入到小数点后 ndigits 位精度的值。
    参数–Number:数字表达式。
    ndigits:精度,即保持小数后几位。任何整数值都可作为有效的 ndigits (正数、零或负数)。
    返回值: 如果 ndigits 被省略或为 None 则返回值将为整数。 否则返回值与 number 的类型相同。
    示例:

    >>> round(3.14159265359, 2)
    3.14
    >>> round(3.14159265359, -1)
    0.0
    >>> round(3.14159265359, 0)
    3.0
    >>> round(314.1592653579, -1)  #当为负数的时候,表示对整数部分进行四舍五入计算。
    310.0
    >>> round(2.675, 2)       #这里并不是错误
    2.67
    

    注意:对浮点数进行round()计算时,结果可能不是预期的结果。例如,round(2.675, 2) 将给出 2.67 而不是期望的 2.68。 这不算是程序错误:这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。详细可以参阅官方文档浮点计算

    S

    56.set([iterable])

    描述:返回一个新的 set 对象,可以选择带有从 iterable 获取的元素。
    参数–iterable:可迭代对象对象。
    返回值:一个新的set对象。
    示例:

    >>>x = set('runoob')
    >>> y = set('google')
    >>> x, y
    (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
    >>> x & y         # 交集
    set(['o'])
    >>> x | y         # 并集
    set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
    >>> x - y         # 差集
    set(['r', 'b', 'u', 'n'])
    

    57.setattr(object, name, value)

    描述:对应函数 getattr(),用于设置属性值,该属性不一定是存在的。
    参数–object:对象。
    name:字符串。
    value:任意值。
    返回值:无。
    示例:

    >>> class A:
    ...     x = 10
    ...
    >>> a = A()
    >>> setattr(a, "x", 20)
    >>> print(a.x)
    20
    

    58.slice(start, stop[, step])

    描述:返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对象。也可以表示为slice(stop)。
    参数–start:起始位置。
    stop:结束位置。
    step:步长。
    返回值:一个切片对象。
    示例:

    >>>myslice = slice(5)    # 设置截取5个元素的切片
    >>> myslice
    slice(None, 5, None)
    >>> arr = range(10)
    >>> arr
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> arr[myslice]         # 截取 5 个元素
    [0, 1, 2, 3, 4]
    

    59.sorted(iterable,key=None,reverse=False)

    描述:对所有可迭代的对象进行排序操作。具有两个可选参数,它们都必须指定为关键字参数。
    参数–iterable:可迭代对象。
    Key:主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。key一般用匿名函数来表示。
    reverse:排序规则,reverse = True 降序 , reverse = False 升序(默认)。
    示例:

     a = [{"name":"aaa", "score":30}, {"name":"bcd", "score":28}, {"name":"bbc", "score":"28"}, {"name":"ddd", "score":35}]
     
     >>> sorted(a, key = lambda x:(x["score"], x["name"]), reverse = True)    #先对分数排序,分数相同按名字排序
     
    [{'name': 'ddd', 'score': 35}, {'name': 'aaa', 'score': 30}, {'name': 'bcd', 'score': 28}, {'name': 'bbc', 'score': 28}]
    

    60.staticmethod(function) —

    描述:将方法转换成静态方法,该方法不强制要求传递参数。与 @staticmethod 相同。
    参数–function:方法名。
    返回值:无。
    示例:

    class A:
        def setx(self, Value):
            self.x = Value
            print(self.x)
        
        @staticmethod    #装饰器
        def setx_s(value):
            x = value
            print(x)
    
        set_x = staticmethod(setx)   #这里将setx() 转变成静态的方法。使得可以直接调用它,但是同时self也作为参数,需要赋值。-----
    
    A.setx_s(10)
    A.set_x(A, 20)
    

    执行结果:

    10
    20
    

    61.str(object=b’’, encoding=‘utf-8’, errors=‘strict’)

    描述:将对象转换成字符串形式。也可以表示为str(object)。
    参数–object:对象。
    encoding:编码格式
    errors:报错级别。详细在open()函数出有介绍。
    示例:

    >>> from datetime import datetime
    >>> now =datetime.now()
    >>> repr(now)
    'datetime.datetime(2019, 9, 20, 15, 41, 45, 660991)'
    >>> str(now)
    '2019-09-20 15:41:45.660991'
    

    与repr()的区别是,str()倾向于可读性,面向用户。repr()倾向于精准的表达,所以输出不是常用类型时会带上数据类型,面向开发人员。参考学python桃子

    62.sum(iterable[,start])

    描述:求一个序列的和。
    参数–itreable:序列,可以是列表,集合,元组。
    start:指定相加的参数,如果没有设置这个值,默认为0。
    返回值:返回序列求和的结果,序列元素全为整数时返回整数,否则返回浮点数。

    >>> l = [1.1, 2.4, 3, 4]
    >>> sum(l)
    10.5
    >>> sum(l, 3)  #将3 作为求和运算的第一个值。
    13.5
    

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

    描述:调用父类的方法。
    参数–type:类。
    object-or-type:类或对象。如果省略第二个参数,则返回的超类对象是未绑定的。 如果第二个参数为obj,则 isinstance(obj, type) 必须为真值,即第二个参数为第一个参数的实例。 如果第二个参数为一个类型,则 issubclass(type2, type) 必须为真值,即第二个参数是第一个参数的子类(这适用于类方法)。
    示例:

    class A:
        def __init__(self):
            print("this is class A")
            self.x = 1
        
        def add(self):
            print("this self is class {0}, this method is A.add()".format(self))
            self.x += 1
            print(self.x, "this is a.add()")
            return self.x
    
    class B(A):
        def __init__(self):
            print("this is class B")
            self.x = 2
    
        def add(self):
            print("this is class {0}, this is B.add()".format(self))
            super().add()
            self.x += 2
            print(self.x, "this is b.add()")
            return self.x
    
    class C(A):
        def __init__(self):
            print("this is class C")
            self.x = 3
        
        def add(self):
            print("this self is class {0}, this is c.add()".format(self))
            super().add()
            self.x += 3
            print(self.x, "this c.add()")
            return self.x
    
    class D(B, C):
        def __init__(self):
            print("this is class D")
            self.x = 4
    
        def add(self):
            print("this self is class {0}, this is D.add()".format(self))
            super().add()
            self.x += 4
            print(self.x, "this d.add()")
            return self.x
    
    d = D()
    temp = d.add()
    print(temp)
    

    执行 结果:

    this is class D
    this self is class <__main__.D object at 0x0000012C056D1668>, this is D.add()
    this is class <__main__.D object at 0x0000012C056D1668>, this is B.add()
    this self is class <__main__.D object at 0x0000012C056D1668>, this is c.add()
    this self is class <__main__.D object at 0x0000012C056D1668>, this method is A.add()
    5 this is a.add()
    8 this c.add()
    10 this is b.add()
    14 this d.add()
    14
    

    可以看到多继承的执行顺序是D->B->C->A。更详细的描述可以参考Huang Huang的博客

    T

    64.tuple([iterable])

    描述:将序列转化成元组。
    参数–iterable:序列,可以是列表,字典,集合。
    返回值:返回一个新的tuple对象。
    示例:

    >>> a = [1, 2, 3]
    >>> tuple(a)
    (1, 2, 3)
    
    >>> b = "abcd"
    >>> tuple(b)
    ('a', 'b', 'c', 'd')
    
    >>> c = dict(a = 1, b = 2, c = 3)  #字典转化成元组时,只保留键。
    >>> tuple(c)
    ('a', 'b', 'c')
    

    65.type()

    描述:有两种形式,type(object),type(name,bases,dict)。如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。
    参数–object:对象。
    name:类名。
    bases:bases 元组列出基类并且会成为 bases 属性。基类的元组。
    dict:而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 dict 属性。
    返回值:如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。
    示例:

    >>> a = 123
    >>> type(a)    #一个参数时
    <class 'int'>
    
    >>> x = type('x', (object,), dict(a = 1))   #三个参数时,等价于创建一个类名为 x 的类,包含一个属性 a = 1
    >>> type(x)
    <class 'type'>
    >>> print(x.a)
    1
    

    66.vars([object])

    描述:返回模块、类、实例或任何其它具有 dict 属性的对象的 dict 属性。
    参数–object:对象。
    返回值:返回对象object的属性和属性值的字典对象,如果没有参数,就打印当前调用位置的属性和属性值 类似 locals()。
    示例:

    >>> x = type('x', (object,), dict(a = 1)) 
    >>> vars(x)
    mappingproxy({'a': 1, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'x' objects>, '__weakref__': <attribute '__weakref__' of 'x' objects>, '__doc__': None})
    >>> x.__dict__
    mappingproxy({'a': 1, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'x' objects>, '__weakref__': <attribute '__weakref__' of 'x' objects>, '__doc__': None})
    >>> dir(x)
    ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a']
    

    可以看出 vars() 的值与 _ _dict_ _的值一致。
    与dir()最显著的区别之一就是vars()会带上属性值。
    注意:在赋值语句 x = 1 执行后,名称 x 可以引用数值 1,这类似字典的键值对,可以用 vars() 返回这个 “字典” 。
    示例:

    >>> x = 1
    >>> d = vars()
    >>> d["x"]
    1
    

    67.zip(*iterable)

    描述:zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
    我们可以使用 list() 转换来输出列表。
    如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
    参数–iterable:一个或多个迭代器。
    返回值:返回一个元组的迭代器,其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。
    示例:

    >>>a = [1,2,3]
    >>> b = [4,5,6]
    >>> c = [4,5,6,7,8]
    >>> zipped = zip(a,b)     # 返回一个对象
    >>> zipped
    <zip object at 0x103abc288>
    >>> list(zipped)  # list() 转换为列表
    [(1, 4), (2, 5), (3, 6)]
    >>> list(zip(a,c))              # 元素个数与最短的列表一致
    [(1, 4), (2, 5), (3, 6)]
     
    >>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反,zip(*) 可理解为解压,返回二维矩阵式
    >>> list(a1)
    [1, 2, 3]
    >>> list(a2)
    [4, 5, 6]
    
    >>> a = dict(name1 = "aaa", name2 = "bbb", name3 = "ccc")  #当参数为字典是只会保留关键字
    >>> b = dict(age1 = 10, age2 = 20, age3 = 30)
    >>> c = zip(a, b)
    >>> list(c) 
    [('name1', 'age1'), ('name2', 'age2'), ('name3', 'age3')]
    

    68._ _import_ _(name, globals=None, locals=None,fromlist=(), level=0)

    描述:动态加载模块。
    参数–name:必选,包,模块名称
    globals:包含全局变量的字典,默认采用 globals(),一般很少使用。
    locals:包含局部变量的字典,默认采用 locals(),一般很少使用。
    fromlist:想要导入的下级模块的名字。
    level:指定是使用绝对还是相对导入。0 表示仅绝对导入, level 为正数值表示相对于模块调用 _ import _() 的目录,将要搜索的父目录层数。

    使用技巧参考传送门

    展开全文
  • python内置函数大全 最近一直在看python的document打算在基础方面重点看一下python的keywordBuild-in FunctionBuild-in ConstantsBuild-in TypesBuild-in Exception这四个方面其实在看的时候发现整个The Python ...
  • Python内置函数大全

    2018-03-12 20:54:00
    Python内置函数 一、数学运算类 abs(x) 求绝对值1、参数可以是整型,也可以是复数2、若参数是复数,则返回复数的模 complex([real[, imag]]) 创建一个复数 ...

    Python内置函数

    一、数学运算类

     

    abs(x) 求绝对值
    1、参数可以是整型,也可以是复数
    2、若参数是复数,则返回复数的模
    complex([real[, imag]]) 创建一个复数
    divmod(a, b) 分别取商和余数
    注意:整型、浮点型都可以
    float([x]) 将一个字符串或数转换为浮点数。如果无参数将返回0.0
    int([x[, base]])  将一个字符转换为int类型,base表示进制
    long([x[, base]])  将一个字符转换为long类型
    pow(x, y[, z])  返回x的y次幂
    range([start], stop[, step])  产生一个序列,默认从0开始
    round(x[, n])  四舍五入
    sum(iterable[, start])  对集合求和
    oct(x) 将一个数字转化为8进制
    hex(x) 将整数x转换为16进制字符串
    chr(i) 返回整数i对应的ASCII字符
    bin(x) 将整数x转换为二进制字符串
    bool([x]) 将x转换为Boolean类型

     

    二、集合类操作

    basestring() str和unicode的超类
    不能直接调用,可以用作isinstance判断
    format(value [, format_spec]) 格式化输出字符串
    格式化的参数顺序从0开始,如“I am {0},I like {1}”
    unichr(i) 返回给定int类型的unicode
    enumerate(sequence [, start = 0]) 返回一个可枚举的对象,该对象的next()方法将返回一个tuple
    iter(o[, sentinel]) 生成一个对象的迭代器,第二个参数表示分隔符
    max(iterable[, args...][key])  返回集合中的最大值
    min(iterable[, args...][key]) 返回集合中的最小值
    dict([arg]) 创建数据字典
    list([iterable])  将一个集合类转换为另外一个集合类
    set() set对象实例化
    frozenset([iterable]) 产生一个不可变的set
    str([object])  转换为string类型
    sorted(iterable[, cmp[, key[, reverse]]])  队集合排序
    tuple([iterable])  生成一个tuple类型
    xrange([start], stop[, step])  xrange()函数与range()类似,但xrnage()并不创建列表,而是返回一个xrange对象,它的行为与列表相似,但是只在需要时才计算列表值,当列表很大时,这个特性能为我们节省内存

     

    三、逻辑判断

    all(iterable) 1、集合中的元素都为真的时候为真
    2、特别的,若为空串返回为True
    any(iterable) 1、集合中的元素有一个为真的时候为真
    2、特别的,若为空串返回为False
    cmp(x, y) 如果x < y ,返回负数;x == y, 返回0;x > y,返回正数

     

    四、反射

    callable(object) 检查对象object是否可调用
    1、类是可以被调用的
    2、实例是不可以被调用的,除非类中声明了__call__方法
    classmethod() 1、注解,用来说明这个方式是个类方法
    2、类方法即可被类调用,也可以被实例调用
    3、类方法类似于Java中的static方法
    4、类方法中不需要有self参数

    compile(source, filename,

    mode[, flags[, dont_inherit]])

    将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。
    1、参数source:字符串或者AST(Abstract Syntax Trees)对象。
    2、参数 filename:代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
    3、参数model:指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。
    4、参数flag和dont_inherit:这两个参数暂不介绍
    dir([object]) 1、不带参数时,返回当前范围内的变量、方法和定义的类型列表;
    2、带参数时,返回参数的属性、方法列表。
    3、如果参数包含方法__dir__(),该方法将被调用。当参数为实例时。
    4、如果参数不包含__dir__(),该方法将最大限度地收集参数信息
    delattr(object, name) 删除object对象名为name的属性
    eval(expression [, globals [, locals]]) 计算表达式expression的值
    execfile(filename [, globals [, locals]]) 用法类似exec(),不同的是execfile的参数filename为文件名,而exec的参数为字符串。
    filter(function, iterable) 构造一个序列,等价于[ item for item in iterable if function(item)]
    1、参数function:返回值为True或False的函数,可以为None
    2、参数iterable:序列或可迭代对象
    getattr(object, name [, defalut]) 获取一个类的属性
    globals() 返回一个描述当前全局符号表的字典
    hasattr(object, name) 判断对象object是否包含名为name的特性
    hash(object) 如果对象object为哈希表类型,返回对象object的哈希值
    id(object) 返回对象的唯一标识
    isinstance(object, classinfo) 判断object是否是class的实例
    issubclass(class, classinfo) 判断是否是子类
    len(s)  返回集合长度
    locals()  返回当前的变量列表
    map(function, iterable, ...)  遍历每个元素,执行function操作
    memoryview(obj)  返回一个内存镜像类型的对象
    next(iterator[, default])  类似于iterator.next()
    object()  基类
    property([fget[, fset[, fdel[, doc]]]])  属性访问的包装类,设置后可以通过c.x=value等来访问setter和getter
    reduce(function, iterable[, initializer])  合并操作,从第一个开始是前两个参数,然后是前两个的结果与第三个合并进行处理,以此类推
    reload(module)  重新加载模块
    setattr(object, name, value) 设置属性值
    repr(object)  将一个对象变幻为可打印的格式
    slice()  
    staticmethod 声明静态方法,是个注解
    super(type[, object-or-type])  引用父类
    type(object) 返回该object的类型
    vars([object])  返回对象的变量,若无参数与dict()方法类似
    bytearray([source [, encoding [, errors]]]) 返回一个byte数组
    1、如果source为整数,则返回一个长度为source的初始化数组;
    2、如果source为字符串,则按照指定的encoding将字符串转换为字节序列;
    3、如果source为可迭代类型,则元素必须为[0 ,255]中的整数;
    4、如果source为与buffer接口一致的对象,则此对象也可以被用于初始化bytearray.
    zip([iterable, ...])  实在是没有看懂,只是看到了矩阵的变幻方面

     

    五、IO操作

     

    file(filename [, mode [, bufsize]]) file类型的构造函数,作用为打开一个文件,如果文件不存在且mode为写或追加时,文件将被创建。添加‘b’到mode参数中,将对文件以二进制形式操作。添加‘+’到mode参数中,将允许对文件同时进行读写操作
    1、参数filename:文件名称。
    2、参数mode:'r'(读)、'w'(写)、'a'(追加)。
    3、参数bufsize:如果为0表示不进行缓冲,如果为1表示进行行缓冲,如果是一个大于1的数表示缓冲区的大小 。
    input([prompt])  获取用户输入
    推荐使用raw_input,因为该函数将不会捕获用户的错误输入
    open(name[, mode[, buffering]])  打开文件
    与file有什么不同?推荐使用open
    print 打印函数
    raw_input([prompt])  设置输入,输入都是作为字符串处理

     

     

    六、open---打开,关闭,close

    模式    描述
    r      打开一个文件为只读。文件指针被放置在文件的开头。这是默认模式。
    rb     打开一个文件只能以二进制格式读取。文件指针被放置在文件的开头。这是默认模式。
    r+     打开用于读和写文件。文件指针置于该文件的开头。
    rb+    打开用于读取和写入二进制格式的文件。文件指针置于该文件的开头。
    w      打开一个文件只写。如果文件存在覆盖该文件。如果该文件不存在,则创建写入新文件。
    wb     打开一个文件只能以二进制格式写入。如果文件存在覆盖该文件。如果该文件不存在,则创建写入新文件。
    w+     打开文件为写入和读取模式。如果文件存在覆盖现有文件。如果该文件不存在,创建用于读写操作的新文件。
    wb+    打开用于以二进制格式写入和读出文件。如果文件存在覆盖现有文件。如果该文件不存在,创建用于读写操作的新文件。
    a      打开用于追加的文件。文件指针是在文件是否存在该文件的末尾。也就是说,该文件是在追加模式。如果该文件不存在,它会创建一个用于写入的新文件。
    ab     打开文件用于二进制格式追加。文件指针是在文件是否存在该文件的末尾。也就是说,文件是在追加模式。 如果该文件不存在,它会创建一个用于写入的新文件。
    a+     打开文件为追加和读取方式。文件指针是在文件是否存在该文件的末尾。该文件以追加模式打开。如果该文件不存在,它将创建用于读写操作的新文件。
    ab+    打开一个文件以附加和二进制格式读取模式。如果该文件存在文件指针在该文件的末尾。该文件以追加模式打开。如果该文件不存在,它将创建读写操作的新文件。

    (1)、只读,r
    f = open("路径文件","r")  
      
    f.write("asdfasdf")  
      
    f.close()

    (2)、w只写模式【不可读;文件不存在则创建;存在则清空内容】

    复制代码
    f =open("ha1.log",'a')  
      
    a1 = f.tell()  ---查看指针位置  
      
    print(a1)  
      
    f.write("nini")  ----如果文件存在清空后出现”nini“  
      
       
      
    a = f.tell()----在查看指针  
      
    print(a)  
      
    f.seek(0)  
      
    #c = f.read()  ----不可读  
      
    #print(c)  
      
    f.close()  -----------关闭  
      
    #print(c)  
    复制代码

    (3)、x 不可读,不存在则创建,存在则报错

    复制代码
    f =open("ha3.log",'x')  
      
    a1 = f.tell()  
      
    print(a1)  
      
    f.write("nini")  
      
       
      
    a = f.tell()  
      
    print(a)  
      
    f.seek(0)  
      
    #c = f.read()  ---=不可读  
      
       
      
    #print(c)  
      
    f.close()  
    复制代码

    (4)、a 不可读,不存在则创建,存在则只追加

    复制代码
    f =open("ha3.log",'a')  
      
    a1 = f.tell()  
      
    print(a1)  
      
    f.write("cccc")-----上面已经写入了"nini " ,存在则只追加内容  
      
    a = f.tell()  
      
    print(a)  
      
    f.seek(0)  
      
    #c = f.read()  
      
    #print(c)  
      
    f.close() 

    转载于:https://www.cnblogs.com/mengqingjian/p/8551914.html

    展开全文
  • 原博文2018-01-24 11:09 −python内置函数大全 python内建函数 最近一直在看python的document,打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in ...

    原博文

    2018-01-24 11:09 −

    python内置函数大全 python内建函数 最近一直在看python的document,打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四...

    相关推荐

    2019-09-28 21:13 −

    Python python是一种跨平台的计算机程序设计语言,是一种面向对象的动态类型语言。 最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越来越多被用于独立的、大型项目的开发。(以上摘自百度百科) Python是一种解释型脚本语言,可以应用于以下领域...

    comment.png

    0

    attention.png

    1991

    2019-12-24 19:55 −

    1 Web应用 https://www.cnblogs.com/yuanchenqi/articles/8869302.html2 http协议 https://www.cnblogs.com/yuanchenqi/articles/8875623...

    2019-12-04 22:39 −

    是不是看到题目Python就点进来了。

    其实,只是个蒟蒻......

    不知道学校发了什么疯,现在连普通的信息课都在讲Python,是怕我们消化不了c++吗?

    虽然心里很不甘心,但不得不承认,许多时候(实际上是大部分),Python都比c++更简单。

    原因:

    1.Python不用打头文件(咳咳,纯属个...

    comment.png

    0

    attention.png

    473

    2019-12-06 14:02 −

    学习提纲

    生成指定范围的数值列表,语法格式如下:

    生成一个包括10哥随机数的列表,要求数的范围在10-100之间,代码如下

    import random

    randomnumber = [random.randint(10,100) for i in range(...

    2019-12-18 15:00 −

    保留字:and,as,assert,break,class,continue,

    def,del,elif,else,except,finally,

    forfromFalse,global,if,import,

    in,is,lambda,nonlocal,not...

    comment.png

    0

    attention.png

    181

    2019-12-24 21:14 −

    python-requests

    python-requests

    作用:能够模拟浏览器向服务器发送请求的库

    requests库的主要方法

    方法描述

    requests.request()构造一个请求,支持以下各种方法requests.get()获取html的主要方法requests.head(...

    comment.png

    0

    attention.png

    534

    2019-12-11 17:16 −

    Redis

    redis是一个key-value存储系统。

    赋值:set name alex查看所有key:keys *查看key对应的value:get name只存活2秒钟:set name jack ex 2

    Python操作Redissudo pip install redis

    1、操作模式r...

    2019-11-27 16:55 −

    1.安装

    需要安装得模块名为pyyaml,直接pip install pyyaml

    导入,直接import yaml

    2.yaml文件的格式

    文件格式输出可以是列表,可以是字典,可以嵌套。层级关系用空格区分,切记,不支持tab缩进

    a)键值对形式

    user: admin

    pwd: 123

    ...

    2019-11-23 12:52 −

    # Python3随手记 - [Python3随手记](#python3%e9%9a%8f%e6%89%8b%e8%ae%b0) - [list方法](#list%e6%96%b9%e6%b3%95) - [os](#os) - [imageio](#imageio) - [Python I...

    展开全文
  • 最近一直在看python的document,打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四个方面,其实在看的时候发现整个《The Python Standard ...

    最近一直在看python的document,打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四个方面,其实在看的时候发现整个《The Python Standard Library》章节都是很不错的,其中描述了很多不错的主题。先把Build-in Function罗列一下吧,初学者的了解,分类可能不准确,一起交流。

    一、数学运算类

    abs(x)

    求绝对值

    1、参数可以是整型,也可以是复数

    2、若参数是复数,则返回复数的模

    complex([real[, imag]])

    创建一个复数

    divmod(a, b)

    分别取商和余数

    注意:整型、浮点型都可以

    float([x])

    将一个字符串或数转换为浮点数。如果无参数将返回0.0

    int([x[, base]])

    将一个字符转换为int类型,base表示进制

    long([x[, base]])

    将一个字符转换为long类型

    pow(x, y[, z])

    返回x的y次幂

    range([start], stop[, step])

    产生一个序列,默认从0开始

    round(x[, n])

    四舍五入

    sum(iterable[, start])

    对集合求和

    oct(x)

    将一个数字转化为8进制

    hex(x)

    将整数x转换为16进制字符串

    chr(i)

    返回整数i对应的ASCII字符

    bin(x)

    将整数x转换为二进制字符串

    bool([x])

    将x转换为Boolean类型

    二、集合类操作

    basestring()

    str和unicode的超类

    不能直接调用,可以用作isinstance判断

    format(value [, format_spec])

    格式化输出字符串

    格式化的参数顺序从0开始,如“I am {0},I like {1}”

    unichr(i)

    返回给定int类型的unicode

    enumerate(sequence [, start = 0])

    返回一个可枚举的对象,该对象的next()方法将返回一个tuple

    iter(o[, sentinel])

    生成一个对象的迭代器,第二个参数表示分隔符

    max(iterable[, args...][key])

    返回集合中的最大值

    min(iterable[, args...][key])

    返回集合中的最小值

    dict([arg])

    创建数据字典

    list([iterable])

    将一个集合类转换为另外一个集合类

    set()

    set对象实例化

    frozenset([iterable])

    产生一个不可变的set

    str([object])

    转换为string类型

    sorted(iterable[, cmp[, key[, reverse]]])

    队集合排序

    tuple([iterable])

    生成一个tuple类型

    xrange([start], stop[, step])

    xrange()函数与range()类似,但xrnage()并不创建列表,而是返回一个xrange对象,它的行为与列表相似,但是只在需要时才计算列表值,当列表很大时,这个特性能为我们节省内存

    三、逻辑判断

    all(iterable)

    1、集合中的元素都为真的时候为真

    2、特别的,若为空串返回为True

    any(iterable)

    1、集合中的元素有一个为真的时候为真

    2、特别的,若为空串返回为False

    cmp(x, y)

    如果x < y ,返回负数;x == y, 返回0;x > y,返回正数

    五、IO操作

    file(filename [, mode [, bufsize]])

    file类型的构造函数,作用为打开一个文件,如果文件不存在且mode为写或追加时,文件将被创建。添加‘b’到mode参数中,将对文件以二进制形式操作。添加‘+’到mode参数中,将允许对文件同时进行读写操作

    1、参数filename:文件名称。

    2、参数mode:'r'(读)、'w'(写)、'a'(追加)。

    3、参数bufsize:如果为0表示不进行缓冲,如果为1表示进行行缓冲,如果是一个大于1的数表示缓冲区的大小 。

    input([prompt])

    获取用户输入

    推荐使用raw_input,因为该函数将不会捕获用户的错误输入

    open(name[, mode[, buffering]])

    打开文件

    与file有什么不同?推荐使用open

    print

    打印函数

    raw_input([prompt])

    设置输入,输入都是作为字符串处理

    六、其他

    help()--帮助信息

    __import__()--没太看明白了,看到了那句“Direct use of __import__() is rare”之后就没心看下去了

    apply()、buffer()、coerce()、intern()---这些是过期的内置函数,故不说明

    七、后记

    内置函数,一般都是因为使用频率比较频繁或是是元操作,所以通过内置函数的形式提供出来,通过对python的内置函数分类分析可以看出来:基本的数据操作基本都是一些数学运算(当然除了加减乘除)、逻辑操作、集合操作、基本IO操作,然后就是对于语言自身的反射操作,还有就是字符串操作,也是比较常用的,尤其需要注意的是反射操作。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 257
精华内容 102
关键字:

python内置函数大全

python 订阅