精华内容
下载资源
问答
  • [img=https://img-bbs.csdn.net/upload/202007/18/1595053935_532252.png][/img]
  • Python内置函数

    万次阅读 多人点赞 2019-05-10 15:10:36
    Python内置函数Python abs()函数Python all() 函数Python any() 函数Python basestring() 函数Python bin() 函数Python bool() 函数Python bytearray() 函数Python callable() 函数Python chr() 函数Python ...

    Python内置函数

    Python abs()函数

    描述:
    abs() 函数返回数字的绝对值。

    abs() 方法的语法:
    abs( x )

    参数:

    x – 数值表达式。

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

    实例:

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

    输出结果:

    abs(-45) :  45
    abs(100.12) :  100.12
    abs(119L) :  119
    

    Python all() 函数

    描述:
    all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 True,如果是返回 True,否则返回 False。
    元素除了是 0、空、None、False 外都算 True。

    以下是 all() 方法的语法:
    all(iterable)

    参数:

    iterable – 元组或列表。

    返回值:
    如果iterable的所有元素不为0、’’、False或者iterable为空,all(iterable)返回True,否则返回False;
    注意:空元组、空列表返回值为True,这里要特别注意。

    all(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
    
    True
    
    all(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
    
    False
    
    all([0, 1,2, 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
    

    Python any() 函数

    描述:
    any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。
    元素除了是 0、空、False 外都算 True。

    any() 方法的语法:
    any(iterable)

    参数:

    iterable – 元组或列表。

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

    实例:

    any(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
    True
     
    any(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
    True
     
    any([0, '', False])        # 列表list,元素全为0,'',false
    False
     
    any(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
    True
     
    any(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
    True
     
    any((0, '', False))        # 元组tuple,元素全为0,'',false
    False
      
    any([]) # 空列表
    False
     
    any(()) # 空元组
    False
    

    Python basestring() 函数

    描述:
    basestring() 方法是 str 和 unicode 的超类(父类),也是抽象类,因此不能被调用和实例化,但可以被用来判断一个对象是否为 str 或者 unicode 的实例,isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。

    basestring() 方法的语法:
    basestring()

    参数:

    返回值:

    实例:

    isinstance("Hello world", str)
    True
    
    isinstance("Hello world", basestring)
    True
    

    Python bin() 函数

    描述:
    bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

    bin() 方法的语法:
    bin(x)

    参数:

    x – int 或者 long int 数字

    返回值:
    字符串

    实例:

    bin(10)
    '0b1010'
    bin(20)
    '0b10100'
    

    Python bool() 函数

    描述:

    bool() 函数用于将给定参数转换为布尔类型,如果没有参数,返回 False。
    bool 是 int 的子类。

    bool() 方法的语法:
    class bool([x])

    参数:

    x – 要进行转换的参数。

    返回值:
    返回 Ture 或 False。

    实例:

    bool()
    False
    
    bool(0)
    False
    
    bool(1)
    True
    
    bool(2)
    True
    
    issubclass(bool, int)  # bool 是 int 子类
    True
    

    Python bytearray() 函数

    描述:
    bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256。

    bytearray()方法语法:
    class bytearray([source[, encoding[, errors]]])

    参数:

    如果 source 为整数,则返回一个长度为 source 的初始化数组;
    如果 source 为字符串,则按照指定的 encoding 将字符串转换为字节序列;
    如果 source 为可迭代类型,则元素必须为[0 ,255] 中的整数;
    如果 source 为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray。
    如果没有输入任何参数,默认就是初始化数组为0个元素。

    返回值:
    返回新字节数组

    实例:

    >>>bytearray()
    bytearray(b'')
    >>> bytearray([1,2,3])
    bytearray(b'\x01\x02\x03')
    >>> bytearray('runoob', 'utf-8')
    bytearray(b'runoob')
    >>>
    

    Python callable() 函数

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

    callable()方法语法:
    callable(object)

    参数:
    object – 对象

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

    实例:

    >>>callable(0)
    False
    >>> callable("runoob")
    False
     
    >>> def add(a, b):
    ...     return a + b
    ... 
    >>> callable(add)             # 函数返回 True
    True
    >>> class A:                  # 类
    ...     def method(self):
    ...             return 0
    ... 
    >>> callable(A)               # 类返回 True
    True
    >>> a = A()
    >>> callable(a)               # 没有实现 __call__, 返回 False
    False
    >>> class B:
    ...     def __call__(self):
    ...             return 0
    ... 
    >>> callable(B)
    True
    >>> b = B()
    >>> callable(b)               # 实现 __call__, 返回 True
    True
    

    Python chr() 函数

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

    chr() 方法的语法:
    chr(i)

    参数:

    i – 可以是10进制也可以是16进制的形式的数字。

    返回值:
    返回值是当前整数对应的 ASCII 字符。

    实例:

    >>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
    0 1 a
    >>> print chr(48), chr(49), chr(97)         # 十进制
    0 1 a
    

    Python classmethod 修饰符

    描述:
    classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。

    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()               # 不需要实例化
    

    输出结果为:

    func2
    1
    foo
    

    Python cmp() 函数

    描述:
    cmp(x,y) 函数用于比较2个对象,如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

    cmp() 方法的语法:
    cmp( x, y )

    参数:

    x – 数值表达式。
    y – 数值表达式。

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

    以下展示了使用 cmp() 方法的实例:

    print "cmp(80, 100) : ", cmp(80, 100)
    print "cmp(180, 100) : ", cmp(180, 100)
    print "cmp(-80, 100) : ", cmp(-80, 100)
    print "cmp(80, -100) : ", cmp(80, -100)
    

    以上实例运行后输出结果为:

    cmp(80, 100) :  -1
    cmp(180, 100) :  1
    cmp(-80, 100) :  -1
    cmp(80, -100) :  1
    

    Python 3.X 的版本中已经没有 cmp 函数,如果你需要实现比较功能,需要引入 operator 模块,适合任何对象,包含的方法有:

    operator.lt(a, b)
    operator.le(a, b)
    operator.eq(a, b)
    operator.ne(a, b)
    operator.ge(a, b)
    operator.gt(a, b)
    operator.lt(a, b)
    operator.le(a, b)
    operator.eq(a, b)
    operator.ne(a, b)
    operator.ge(a, b)
    operator.gt(a, b)
    实例

    import operator
    operator.eq('hello', 'name');
    operator.eq('hello', 'hello');
    

    结果:

    False
    True
    

    Python compile() 函数

    描述:
    compile() 函数将一个字符串编译为字节代码。

    compile() 方法的语法:
    compile(source, filename, mode[, flags[, dont_inherit]])

    参数:

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

    返回值
    返回表达式执行结果。

    以下展示了使用 compile 函数的实例:

    >>>str = "for i in range(0,10): print(i)" 
    >>> c = compile(str,'','exec')   # 编译为字节代码对象 
    >>> c
    <code object <module> at 0x10141e0b0, file "", line 1>
    >>> exec(c)
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> str = "3 * 4 + 5"
    >>> a = compile(str,'','eval')
    >>> eval(a)
    17
    

    Python complex() 函数

    描述

    complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。。

    complex 语法:
    class complex([real[, imag]])

    参数说明:

    real – int, long, float或字符串;
    imag – int, long, float;

    返回值
    返回一个复数。

    以下实例展示了 complex 的使用方法:

    >>>complex(1, 2)
    (1 + 2j)
     
    >>> complex(1)    # 数字
    (1 + 0j)
     
    >>> complex("1")  # 当做字符串处理
    (1 + 0j)
     
    # 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
    >>> complex("1+2j")
    (1 + 2j)
    

    Python delattr() 函数

    描述:

    delattr 函数用于删除属性。
    delattr(x, ‘foobar’) 相等于 del x.foobar。

    delattr 语法:
    delattr(object, name)

    参数:

    object – 对象。
    name – 必须是对象的属性。

    返回值:
    无。

    以下实例展示了 delattr 的使用方法:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class Coordinate:
        x = 10
        y = -5
        z = 0
     
    point1 = Coordinate() 
     
    print('x = ',point1.x)
    print('y = ',point1.y)
    print('z = ',point1.z)
     
    delattr(Coordinate, 'z')
     
    print('--删除 z 属性后--')
    print('x = ',point1.x)
    print('y = ',point1.y)
     
    # 触发错误
    print('z = ',point1.z)
    
    输出结果:
    
    ('x = ', 10)
    ('y = ', -5)
    ('z = ', 0)
    --删除 z 属性后--
    ('x = ', 10)
    ('y = ', -5)
    Traceback (most recent call last):
      File "test.py", line 22, in <module>
        print('z = ',point1.z)
    AttributeError: Coordinate instance has no attribute 'z'
    

    Python dict() 函数

    描述:
    dict() 函数用于创建一个字典。

    dict 语法:
    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg)

    参数说明:

    **kwargs – 关键字
    mapping – 元素的容器。
    iterable – 可迭代对象。

    返回值:
    返回一个字典。

    以下实例展示了 dict 的使用方法:

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

    Python dir() 函数

    描述:
    dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

    dir 语法:
    dir([object])

    参数说明:

    object – 对象、变量、类型。

    返回值:
    返回模块的属性列表。

    以下实例展示了 dir 的使用方法:

    >>>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']
    >>>
    

    Python divmod() 函数

    描述:
    python divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。

    函数语法:
    divmod(a, b)
    Python divmod() 函数

    Python 内置函数 Python 内置函数

    python divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。

    在 python 2.3 版本之前不允许处理复数。
    函数语法

    divmod(a, b)

    参数说明:

    a: 数字
    b: 数字

    实例

    >>>divmod(7, 2)
    (3, 1)
    >>> divmod(8, 2)
    (4, 0)
    >>> divmod(1+2j,1+0.5j)
    ((1+0j), 1.5j)
    

    Python enumerate() 函数

    描述:
    enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

    enumerate() 方法的语法:
    enumerate(sequence, [start=0])

    参数:

    sequence – 一个序列、迭代器或其他支持迭代对象。
    start – 下标起始位置。

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

    以下展示了使用 enumerate() 方法的实例:

    >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    >>> list(enumerate(seasons))
    [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    >>> list(enumerate(seasons, start=1))       # 下标从 1 开始
    [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
    

    普通的 for 循环

    >>>i = 0
    >>> seq = ['one', 'two', 'three']
    >>> for element in seq:
    ...     print i, seq[i]
    ...     i +=1
    ... 
    0 one
    1 two
    2 three
    

    for 循环使用 enumerate

    >>>seq = ['one', 'two', 'three']
    >>> for i, element in enumerate(seq):
    ...     print i, element
    ... 
    0 one
    1 two
    2 three
    

    Python eval() 函数

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

    eval() 方法的语法:
    eval(expression[, globals[, locals]])

    参数:

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

    返回值:
    返回表达式计算结果。

    以下展示了使用 eval() 方法的实例:

    >>>x = 7
    >>> eval( '3 * x' )
    21
    >>> eval('pow(2,2)')
    4
    >>> eval('2 + 2')
    4
    >>> n=81
    >>> eval("n + 4")
    85
    

    Python execfile() 函数

    描述:

    execfile() 函数可以用来执行一个文件。

    execfile() 方法的语法:
    execfile(filename[, globals[, locals]])

    参数

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

    返回值
    返回表达式执行结果。

    以下展示了使用 execfile 函数的实例:

    假设文件 hello.py,内容如下:

    print('runoob');
    

    execfile 调用该文件

    >>>execfile('hello.py')
    runoob
    

    Python file() 函数

    描述
    file() 函数用于创建一个 file 对象,它有一个别名叫 open(),更形象一些,它们是内置函数。参数是以字符串的形式传递的。
    更多文件操作可参考:Python 文件I/O。

    file() 方法的语法:
    file(name[, mode[, buffering]])

    参数

    name – 文件名
    mode – 打开模式
    buffering – 0 表示不缓冲,如果为 1 表示进行行缓冲,大于 1 为缓冲区大小。

    返回值
    文件对象。
    实例

    测试文件 test.txt,内容如下:

    RUNOOB1
    RUNOOB2
    
    >>>f = file('test.txt')
    >>> f.read()
    'RUNOOB1\nRUNOOB2\n'
    

    Python filter() 函数

    描述
    filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
    该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。

    注意: Pyhton2.7 返回列表,Python3.x 返回迭代器对象,具体内容可以查看:Python3 filter() 函数
    

    filter() 方法的语法:
    filter(function, iterable)

    参数

    function – 判断函数。
    iterable – 可迭代对象。

    返回值
    返回列表。

    以下展示了使用 filter 函数的实例:
    过滤出列表中的所有奇数:

    def is_odd(n):
        return n % 2 == 1
     
    newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    print(newlist)
    

    输出结果 :

    [1, 3, 5, 7, 9]
    

    过滤出1~100中平方根是整数的数:

    import math
    def is_sqr(x):
        return math.sqrt(x) % 1 == 0
     
    newlist = filter(is_sqr, range(1, 101))
    print(newlist)
    

    输出结果 :

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

    Python float() 函数

    描述
    float() 函数用于将整数和字符串转换成浮点数。

    float()方法语法:
    class float([x])

    参数

    x – 整数或字符串

    返回值
    返回浮点数。

    以下实例展示了 float() 的使用方法:

    >>>float(1)
    1.0
    >>> float(112)
    112.0
    >>> float(-123.6)
    -123.6
    >>> float('123')     # 字符串
    123.0
    

    Python format 格式化函数

    以下实例展示了format()的使用方法:

    "{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
    "{0} {1}".format("hello", "world")  # 设置指定位置
    "{1} {0} {1}".format("hello", "world")  # 设置指定位置
    

    输出结果:

    'hello world'
    'hello world'
    'world hello world'
    

    Python frozenset() 函数

    描述

    frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。

    frozenset() 函数语法:

    class frozenset([iterable])

    参数

    iterable – 可迭代的对象,比如列表、字典、元组等等。

    返回值

    返回新的 frozenset 对象,如果不提供任何参数,默认会生成空集合。

    以下实例展示了 frozenset() 的使用方法:

    >>>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'])   # 创建不可变集合
    >>>
    

    Python getattr() 函数

    描述
    getattr() 函数用于返回一个对象属性值。

    getattr 语法:

    getattr(object, name[, default])

    参数

    object – 对象。
    name – 字符串,对象属性。
    default – 默认返回值,如果不提供该参数,在没有对应属性时,将触发 AttributeError。
    返回值
    返回对象属性值。

    以下实例展示了 getattr 的使用方法:

    >>>class A(object):
    ...     bar = 1
    ... 
    >>> a = A()
    >>> getattr(a, 'bar')        # 获取属性 bar 值
    1
    >>> getattr(a, 'bar2')       # 属性 bar2 不存在,触发异常
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: 'A' object has no attribute 'bar2'
    >>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在,但设置了默认值
    3
    >>>
    

    Python globals() 函数

    描述

    globals() 函数会以字典类型返回当前位置的全部全局变量。

    globals() 函数语法:

    globals()

    参数

    返回值

    返回全局变量的字典。

    以下实例展示了 globals() 的使用方法:

    >>>a='runoob'
    >>> print(globals()) # globals 函数返回一个全局变量的字典,包括所有导入的变量。
    {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
    

    Python hasattr() 函数

    描述

    hasattr() 函数用于判断对象是否包含对应的属性。

    hasattr 语法:

    hasattr(object, name)

    参数

    object – 对象。
    name – 字符串,属性名。
    返回值
    如果对象有该属性返回 True,否则返回 False。

    以下实例展示了 hasattr 的使用方法:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    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'))  # 没有该属性
    

    输出结果:

    True
    True
    True
    False
    

    Python hash() 函数

    描述

    hash() 用于获取取一个对象(字符串或者数值等)的哈希值。

    hash 语法:

    hash(object)

    参数说明:

    object – 对象;
    返回值
    返回对象的哈希值。

    以下实例展示了 hash 的使用方法:

    >>>hash('test')            # 字符串
    2314058222102390712
    >>> hash(1)                 # 数字
    1
    >>> hash(str([1,2,3]))      # 集合
    1335416675971793195
    >>> hash(str(sorted({'1':1}))) # 字典
    7666464346782421378
    >>>
    

    Python hash() 函数

    描述
    hash() 用于获取取一个对象(字符串或者数值等)的哈希值。

    hash 语法:

    hash(object)

    参数说明:

    object – 对象;
    返回值
    返回对象的哈希值。

    以下实例展示了 hash 的使用方法:

    >>>hash('test')            # 字符串
    2314058222102390712
    >>> hash(1)                 # 数字
    1
    >>> hash(str([1,2,3]))      # 集合
    1335416675971793195
    >>> hash(str(sorted({'1':1}))) # 字典
    7666464346782421378
    >>>
    

    Python hex() 函数

    描述

    hex() 函数用于将10进制整数转换成16进制,以字符串形式表示。

    hex 语法:

    hex(x)

    参数说明:

    x – 10进制整数
    返回值
    返回16进制数,以字符串形式表示。

    以下实例展示了 hex 的使用方法:

    >>>hex(255)
    '0xff'
    >>> hex(-42)
    '-0x2a'
    >>> hex(1L)
    '0x1L'
    >>> hex(12)
    '0xc'
    >>> type(hex(12))
    <class 'str'>      # 字符串
    

    Python id() 函数

    描述

    id() 函数用于获取对象的内存地址。

    id 语法:

    id([object])

    参数说明:

    object – 对象。
    返回值
    返回对象的内存地址。

    以下实例展示了 id 的使用方法:

    >>>a = 'runoob'
    >>> id(a)
    4531887632
    >>> b = 1
    >>> id(b)
    140588731085608
    

    Python3 input() 函数

    Python3.x 中 input() 函数接受一个标准输入数据,返回为 string 类型。
    注意:在 Python3.x 中 raw_input() 和 input() 进行了整合,去除了 raw_input( ),仅保留了input( )函数,其接收任意任性输入,将所有输入默认为字符串处理,并返回字符串类型。

    函数语法

    input([prompt])

    参数说明:

    prompt: 提示信息

    input() 需要输入 python 表达式

    >>>a = input("input:")
    input:123                  # 输入整数
    >>> type(a)
    <class 'str'>              # 字符串
    >>> a = input("input:")    
    input:runoob              # 正确,字符串表达式
    >>> type(a)
    <class 'str'>             # 字符串
    

    Python int() 函数

    描述

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

    以下是 int() 方法的语法:

    class int(x, base=10)

    参数

    x – 字符串或数字。
    base – 进制数,默认十进制。
    返回值
    返回整型数据。

    以下展示了使用 int() 方法的实例:

    >>>int()               # 不传入参数时,得到结果0
    0
    >>> int(3)
    3
    >>> int(3.6)
    3
    >>> int('12',16)        # 如果是带参数base的话,12要以字符串的形式进行输入,12 为 16进制
    18
    >>> int('0xa',16)  
    10  
    >>> int('10',8)  
    8
    

    #Python isinstance() 函数

    描述
    isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。
    isinstance() 与 type() 区别:
    type() 不会认为子类是一种父类类型,不考虑继承关系。
    isinstance() 会认为子类是一种父类类型,考虑继承关系。
    如果要判断两个类型是否相同推荐使用 isinstance()。

    以下是 isinstance() 方法的语法:

    isinstance(object, classinfo)

    参数

    object – 实例对象。
    classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
    返回值
    如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False。。

    以下展示了使用 isinstance 函数的实例:

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

    type() 与 isinstance()区别:

    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
    

    Python issubclass() 函数

    描述

    issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

    以下是 issubclass() 方法的语法:

    issubclass(class, classinfo)

    参数

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

    以下展示了使用 issubclass 函数的实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class A:
        pass
    class B(A):
        pass
        
    print(issubclass(B,A))    # 返回 True
    

    Python iter() 函数

    描述

    iter() 函数用来生成迭代器。

    以下是 iter() 方法的语法:

    iter(object[, sentinel])

    参数

    object – 支持迭代的集合对象。
    sentinel – 如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object。
    打开模式
    返回值
    迭代器对象。

    实例

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

    Python len()方法

    描述

    Python len() 方法返回对象(字符、列表、元组等)长度或项目个数。

    len()方法语法:

    len( s )

    参数

    s – 对象。
    返回值
    返回对象长度。

    以下实例展示了 len() 的使用方法:

    >>>str = "runoob"
    >>> len(str)             # 字符串长度
    6
    >>> l = [1,2,3,4,5]
    >>> len(l)               # 列表元素个数
    5
    

    Python List list()方法

    描述
    list() 方法用于将元组转换为列表。

    注:元组与列表是非常类似的,区别在于元组的元素值不能修改,元组是放在括号中,列表是放于方括号中。

    list()方法语法:

    list( tup )

    参数

    tup – 要转换为列表的元组。
    返回值
    返回列表。

    以下实例展示了 list()函数的使用方法:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    aTuple = (123, 'xyz', 'zara', 'abc');
    aList = list(aTuple)
     
    print "列表元素 : ", aList
    以上实例输出结果如下:
    
    列表元素 :  [123, 'xyz', 'zara', 'abc']
    

    Python locals() 函数

    描述

    locals() 函数会以字典类型返回当前位置的全部局部变量。
    对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

    locals() 函数语法:

    locals()

    参数

    返回值

    返回字典类型的局部变量。

    以下实例展示了 locals() 的使用方法:

    >>>def runoob(arg):    # 两个局部变量:arg、z
    ...     z = 1
    ...     print (locals())
    ... 
    >>> runoob(4)
    {'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
    >>>
    

    Python long() 函数

    描述

    long() 函数将数字或字符串转换为一个长整型。

    long() 函数语法:

    class long(x, base=10)

    参数

    x – 字符串或数字。
    base – 可选,进制数,默认十进制。
    返回值
    返回长整型数。

    以下实例展示了 long() 的使用方法:

    >>>long()
    0L
    >>> long(1)
    1L
    >>> long('123')
    123L
    >>> 
    >>>
    

    Python map() 函数

    描述

    map() 会根据提供的函数对指定序列做映射。
    第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。

    map() 函数语法:

    map(function, iterable, …)

    参数

    function – 函数
    iterable – 一个或多个序列

    返回值

    Python 2.x 返回列表。
    Python 3.x 返回迭代器。

    以下实例展示了 map() 的使用方法:

    >>>def square(x) :            # 计算平方数
    ...     return x ** 2
    ... 
    >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
    [1, 4, 9, 16, 25]
    >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
    [1, 4, 9, 16, 25]
    
    # 提供了两个列表,对相同位置的列表数据进行相加
    >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
    [3, 7, 11, 15, 19]
    

    Python max() 函数

    描述

    max() 方法返回给定参数的最大值,参数可以为序列。

    以下是 max() 方法的语法:

    max( x, y, z, … )

    参数

    x – 数值表达式。
    y – 数值表达式。
    z – 数值表达式。

    返回值

    返回给定参数的最大值。

    以下展示了使用 max() 方法的实例:

    实例(Python 2.0+)
    #!/usr/bin/python
     
    print "max(80, 100, 1000) : ", max(80, 100, 1000)
    print "max(-20, 100, 400) : ", max(-20, 100, 400)
    print "max(-80, -20, -10) : ", max(-80, -20, -10)
    print "max(0, 100, -400) : ", max(0, 100, -400)
    
    实例(Python 3.0+)
    print ("max(80, 100, 1000) : ", max(80, 100, 1000))
    print ("max(-20, 100, 400) : ", max(-20, 100, 400))
    print ("max(-80, -20, -10) : ", max(-80, -20, -10))
    print ("max(0, 100, -400) : ", max(0, 100, -400))
    

    以上实例运行后输出结果为:

    max(80, 100, 1000) :  1000
    max(-20, 100, 400) :  400
    max(-80, -20, -10) :  -10
    max(0, 100, -400) :  100
    

    # Python memoryview() 函数

    描述

    memoryview() 函数返回给定参数的内存查看对象(Momory view)。
    所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问。

    memoryview 语法:

    memoryview(obj)

    参数说明:

    obj – 对象
    返回值
    返回元组列表。

    以下实例展示了 memoryview 的使用方法:

    Python2.x 应用:

    >>>v = memoryview('abcefg')
    >>> v[1]
    'b'
    >>> v[-1]
    'g'
    >>> v[1:4]
    <memory at 0x77ab28>
    >>> v[1:4].tobytes()
    'bce'
    

    Python3.x 应用:

    >>>v = memoryview(bytearray("abcefg", 'utf-8'))
    >>> print(v[1])
    98
    >>> print(v[-1])
    103
    >>> print(v[1:4])
    <memory at 0x10f543a08>
    >>> print(v[1:4].tobytes())
    b'bce'
    >>>
    

    Python min() 函数

    描述

    min() 方法返回给定参数的最小值,参数可以为序列。

    以下是 min() 方法的语法:

    min( x, y, z, … )

    参数

    x – 数值表达式。
    y – 数值表达式。
    z – 数值表达式。

    返回值

    返回给定参数的最小值。

    以下展示了使用 min() 方法的实例:

    #!/usr/bin/python
    
    print "min(80, 100, 1000) : ", min(80, 100, 1000)
    print "min(-20, 100, 400) : ", min(-20, 100, 400)
    print "min(-80, -20, -10) : ", min(-80, -20, -10)
    print "min(0, 100, -400) : ", min(0, 100, -400)
    

    以上实例运行后输出结果为:

    min(80, 100, 1000) :  80
    min(-20, 100, 400) :  -20
    min(-80, -20, -10) :  -80
    min(0, 100, -400) :  -400
    

    Python next() 函数

    描述

    next() 返回迭代器的下一个项目。

    next 语法:

    next(iterator[, default])

    参数说明:

    iterator – 可迭代对象
    default – 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。

    返回值

    返回对象帮助信息。

    以下实例展示了 next 的使用方法:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    # 首先获得Iterator对象:
    it = iter([1, 2, 3, 4, 5])
    # 循环:
    while True:
        try:
            # 获得下一个值:
            x = next(it)
            print(x)
        except StopIteration:
            # 遇到StopIteration就退出循环
            break
    

    输出结果为:

    1
    2
    3
    4
    5
    

    Python object()函数

    Python object() 函数

    Python oct() 函数

    描述

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

    oct 语法:

    oct(x)

    参数说明:

    x – 整数。
    返回值
    返回8进制字符串。

    以下实例展示了 oct 的使用方法:

    >>>oct(10)
    '012'
    >>> oct(20)
    '024'
    >>> oct(15)
    '017'
    >>>
    

    Python open() 函数

    python open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。

    更多文件操作可参考:Python 文件I/O

    函数语法

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

    参数说明:

    name : 一个包含了你要访问的文件名称的字符串值。
    mode : mode 决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读®。
    buffering : 如果 buffering 的值被设为 0,就不会有寄存。如果 buffering 的值取 1,访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数,表明了这就是的寄存区的缓冲大小。如果取负值,寄存区的缓冲大小则为系统默认。

    不同模式打开文件的完全列表:

    模式描述
    r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
    rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
    r+打开一个文件用于读写。文件指针将会放在文件的开头。
    rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
    w打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    wb以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    w+打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    wb+以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    a打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    ab以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    a+打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
    ab+以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。

    file 对象方法

    file.read([size]):size 未指定则返回整个文件,如果文件大小 >2 倍内存则有问题,f.read()读到文件尾时返回""(空字串)。

    file.readline():返回一行。

    file.readlines([size]) :返回包含size行的列表, size 未指定则返回全部行。

    for line in f: print line :通过迭代器访问。

    f.write(“hello\n”):如果要写入字符串以外的数据,先将他转换为字符串。

    f.tell():返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。

    f.seek(偏移量,[起始位置]):用来移动文件指针。

    偏移量: 单位为比特,可正可负
    起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
    f.close() 关闭文件

    Python ord() 函数

    描述

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

    以下是 ord() 方法的语法:

    ord©

    参数

    c – 字符。
    返回值
    返回值是对应的十进制整数。

    以下展示了使用 ord() 方法的实例:

    >>>ord('a')
    97
    >>> ord('b')
    98
    >>> ord('c')
    99
    

    Python pow() 函数

    描述

    pow() 方法返回 xy(x的y次方) 的值。

    以下是 math 模块 pow() 方法的语法:

    import math

    math.pow( x, y )

    内置的 pow() 方法

    pow(x, y[, z])

    函数是计算x的y次方,如果z在存在,则再对结果进行取模,其结果等效于pow(x,y) %z
    注意:pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。

    参数

    x – 数值表达式。
    y – 数值表达式。
    z – 数值表达式。

    返回值

    返回 xy(x的y次方) 的值。

    以下展示了使用 pow() 方法的实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    import math   # 导入 math 模块
     
    print "math.pow(100, 2) : ", math.pow(100, 2)
    # 使用内置,查看输出结果区别
    print "pow(100, 2) : ", pow(100, 2)
     
    print "math.pow(100, -2) : ", math.pow(100, -2)
    print "math.pow(2, 4) : ", math.pow(2, 4)
    print "math.pow(3, 0) : ", math.pow(3, 0)
    

    以上实例运行后输出结果为:

    math.pow(100, 2) :  10000.0
    pow(100, 2) :  10000
    math.pow(100, -2) :  0.0001
    math.pow(2, 4) :  16.0
    math.pow(3, 0) :  1.0
    

    Python print() 函数

    描述

    print() 方法用于打印输出,最常见的一个函数。
    print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字。

    以下是 print() 方法的语法:

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

    参数

    objects – 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
    sep – 用来间隔多个对象,默认值是一个空格。
    end – 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串。
    file – 要写入的文件对象。

    返回值

    无。

    以下展示了使用 print 函数的实例:
    Python3 下测试

    >>>print(1)  
    1  
    >>> print("Hello World")  
    Hello World  
     
    >>> a = 1
    >>> b = 'runoob'
    >>> print(a,b)
    1 runoob
     
    >>> print("aaa""bbb")
    aaabbb
    >>> print("aaa","bbb")
    aaa bbb
    >>> 
     
    >>> print("I","Love","Python",sep=".")  # 设置间隔符
    I.Love.Python
    

    Python property() 函数

    描述

    property() 函数的作用是在新式类中返回属性值。

    以下是 property() 方法的语法:

    class property([fget[, fset[, fdel[, doc]]]])

    参数

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

    返回值

    返回新式类属性。

    实例

    定义一个可控属性值 x
    class C(object):
        def __init__(self):
            self._x = None
     
        def getx(self):
            return self._x
     
        def setx(self, value):
            self._x = value
     
        def delx(self):
            del self._x
     
        x = property(getx, setx, delx, "I'm the 'x' property.")
    

    如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter , del c.x 触发 deleter。
    如果给定 doc 参数,其将成为这个属性值的 docstring,否则 property 函数就会复制 fget 函数的 docstring(如果有的话)。
    将 property 函数用作装饰器可以很方便的创建只读属性:

    class Parrot(object):
        def __init__(self):
            self._voltage = 100000
     
        @property
        def voltage(self):
            """Get the current voltage."""
            return self._voltage
    

    上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
    property 的 getter,setter 和 deleter 方法同样可以用作装饰器:

    class C(object):
        def __init__(self):
            self._x = None
     
        @property
        def x(self):
            """I'm the 'x' property."""
            return self._x
     
        @x.setter
        def x(self, value):
            self._x = value
     
        @x.deleter
        def x(self):
            del self._x
    

    这个代码和第一个例子完全相同,但要注意这些额外函数的名字和 property 下的一样,例如这里的 x。

    Python range() 函数用法

    描述
    python range() 函数可创建一个整数列表,一般用在 for 循环中。

    函数语法

    range(start, stop[, step])

    参数说明:

    start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5);
    stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5
    step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)

    实例

    >>>range(10)        # 从 0 开始到 10
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> range(1, 11)     # 从 1 开始到 11
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    >>> range(0, 30, 5)  # 步长为 5
    [0, 5, 10, 15, 20, 25]
    >>> range(0, 10, 3)  # 步长为 3
    [0, 3, 6, 9]
    >>> range(0, -10, -1) # 负数
    [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
    >>> range(0)
    []
    >>> range(1, 0)
    []
    

    以下是 range 在 for 中的使用,循环出runoob 的每个字母:

    >>>x = 'runoob'
    >>> for i in range(len(x)) :
    ...     print(x[i])
    ... 
    r
    u
    n
    o
    o
    b
    >>>
    

    Python raw_input() 函数

    描述
    python raw_input() 用来获取控制台的输入。
    raw_input() 将所有输入作为字符串看待,返回字符串类型。

    注意: input() 和 raw_input() 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。
    除非对 input() 有特别需要,否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。

    注意: python3 里 input() 默认接收到的是 str 类型。

    函数语法

    raw_input([prompt])

    参数说明:

    prompt: 可选,字符串,可作为一个提示语。

    实例
    raw_input() 将所有输入作为字符串看待

    >>>a = raw_input("input:")
    input:123
    >>> type(a)
    <type 'str'>              # 字符串
    >>> a = raw_input("input:")
    input:runoob
    >>> type(a)
    <type 'str'>              # 字符串
    >>>
    

    input() 需要输入 python 表达式

    >>>a = input("input:")
    input:123                  # 输入整数
    >>> type(a)
    <type 'int'>               # 整型
    >>> a = input("input:")    
    input:"runoob"           # 正确,字符串表达式
    >>> type(a)
    <type 'str'>             # 字符串
    >>> a = input("input:")
    input:runoob               # 报错,不是表达式
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<string>", line 1, in <module>
    NameError: name 'runoob' is not defined
    <type 'str'>
    

    Python reduce() 函数

    描述

    reduce() 函数会对参数序列中元素进行累积。
    函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。

    reduce() 函数语法:

    reduce(function, iterable[, initializer])

    参数

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

    返回值

    返回函数计算结果。

    以下实例展示了 reduce() 的使用方法:

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

    Python reload() 函数

    Python3.0+ 重要!!!

    说明:Python 3.0 把 reload 内置函数移到了 imp 标准库模块中。它仍然像以前一样重载文件,但是,必须导入它才能使用。

    方法一:

    from imp import reload
    reload(module)
    方法二:

    import imp
    imp.reload(module)

    描述

    reload() 用于重新载入之前载入的模块。

    reload() 函数语法:

    reload(module)

    参数

    module – 模块对象。

    返回值

    返回模块对象。

    以下实例展示了 reload() 的使用方法:

    重新载入 sys 模块,并设置默认编码为 utf8
    >>>import sys
    >>> sys.getdefaultencoding()            # 当前默认编码
    'ascii'
    >>> reload(sys)                         # 使用 reload
    <module 'sys' (built-in)>
    >>> sys.setdefaultencoding('utf8')      # 设置编码
    >>> sys.getdefaultencoding()
    'utf8'
    >>>
    

    Python repr() 函数

    描述

    repr() 函数将对象转化为供解释器读取的形式。

    以下是 repr() 方法的语法:

    repr(object)

    参数

    object – 对象。

    返回值

    返回一个对象的 string 格式。

    以下展示了使用 repr() 方法的实例:

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

    Python List reverse()方法

    描述

    reverse() 函数用于反向列表中元素。

    reverse()方法语法:

    list.reverse()

    参数

    NA。

    返回值

    该方法没有返回值,但是会对列表的元素进行反向排序。

    以下实例展示了 reverse()函数的使用方法:

    #!/usr/bin/python
    
    aList = [123, 'xyz', 'zara', 'abc', 'xyz']
    
    aList.reverse()
    print "List : ", aList
    以上实例输出结果如下:
    
    List :  ['xyz', 'abc', 'zara', 'xyz', 123]
    

    Python round() 函数

    描述

    round() 方法返回浮点数x的四舍五入值。

    以下是 round() 方法的语法:

    round( x [, n] )

    参数

    x – 数值表达式。
    n – 数值表达式。

    返回值
    返回浮点数x的四舍五入值。

    以下展示了使用 round() 方法的实例:

    #!/usr/bin/python
    
    print "round(80.23456, 2) : ", round(80.23456, 2)
    print "round(100.000056, 3) : ", round(100.000056, 3)
    print "round(-100.000056, 3) : ", round(-100.000056, 3)
    

    以上实例运行后输出结果为:

    round(80.23456, 2) :  80.23
    round(100.000056, 3) :  100.0
    round(-100.000056, 3) :  -100.0
    

    Python set() 函数

    描述

    set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。

    set 语法:

    class 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'])
    >>>
    

    Python setattr() 函数

    描述
    setattr() 函数对应函数 getattr(),用于设置属性值,该属性不一定是存在的。

    setattr() 语法:

    setattr(object, name, value)

    参数

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

    返回值
    无。

    以下实例展示了 setattr() 函数的使用方法:

    对已存在的属性进行赋值:

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

    如果属性不存在会创建一个新的对象属性,并对属性赋值:

    >>>class A():
    ...     name = "runoob"
    ... 
    >>> a = A()
    >>> setattr(a, "age", 28)
    >>> print(a.age)
    28
    >>>
    

    Python slice() 函数

    描述

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

    slice 语法:

    class slice(stop)
    class slice(start, stop[, step])

    参数说明:

    start – 起始位置
    stop – 结束位置
    step – 间距

    返回值

    返回一个切片对象。

    以下实例展示了 slice 的使用方法:

    >>>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]
    >>>
    

    Python sorted() 函数

    描述

    sorted() 函数对所有可迭代的对象进行排序操作。
    sort 与 sorted 区别:
    sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
    list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

    sorted 语法:

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

    参数说明:

    iterable – 可迭代对象。
    cmp – 比较的函数,这个具有两个参数,参数的值都是从可迭代对象中取出,此函数必须遵守的规则为,大于则返回1,小于则返回-1,等于则返回0。
    key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    reverse – 排序规则,reverse = True 降序 , reverse = False 升序(默认)。

    返回值

    返回重新排序的列表。

    以下实例展示了 sorted 的使用方法:

    >>>a = [5,7,6,3,4,1,2]
    >>> b = sorted(a)       # 保留原列表
    >>> a 
    [5, 7, 6, 3, 4, 1, 2]
    >>> b
    [1, 2, 3, 4, 5, 6, 7]
     
    >>> L=[('b',2),('a',1),('c',3),('d',4)]
    >>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
    [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
    >>> sorted(L, key=lambda x:x[1])               # 利用key
    [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
     
     
    >>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    >>> sorted(students, key=lambda s: s[2])            # 按年龄排序
    [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
     
    >>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
    [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    >>>
    

    Python staticmethod() 函数

    描述
    python staticmethod 返回函数的静态方法。
    该方法不强制要求传递参数,如下声明一个静态方法:

    class C(object):
        @staticmethod
        def f(arg1, arg2, ...):
            ...
    

    以上实例声明了静态方法 f,类可以不用实例化就可以调用该方法 C.f(),当然也可以实例化后调用 C().f()。

    函数语法
    staticmethod(function)

    参数说明:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class C(object):
        @staticmethod
        def f():
            print('Python');
     
    C.f();          # 静态方法无需实例化
    cobj = C()
    cobj.f()        # 也可以实例化后调用
    

    以上实例输出结果为:

    Python
    Python
    

    Python str() 函数

    描述

    str() 函数将对象转化为适于人阅读的形式。

    以下是 str() 方法的语法:

    class str(object=’’)

    参数

    object – 对象。
    返回值
    返回一个对象的string格式。

    以下展示了使用 str() 方法的实例:

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

    Python sum() 函数

    描述

    sum() 方法对系列进行求和计算。

    以下是 sum() 方法的语法:

    sum(iterable[, start])

    参数

    iterable – 可迭代对象,如:列表、元组、集合。
    start – 指定相加的参数,如果没有设置这个值,默认为0。

    返回值

    返回计算结果。

    以下展示了使用 sum 函数的实例:

    >>>sum([0,1,2])  
    3  
    >>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
    10
    >>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
    12
    

    Python super() 函数

    描述
    super() 函数是用于调用父类(超类)的一个方法。

    super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。

    MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

    以下是 super() 方法的语法:

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

    参数

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

    Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :

    Python3.x 实例:

    class A:
         def add(self, x):
             y = x+1
             print(y)
    class B(A):
        def add(self, x):
            super().add(x)
    b = B()
    b.add(2)  # 3
    

    Python2.x 实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class A(object):   # Python2.x 记得继承 object
        def add(self, x):
             y = x+1
             print(y)
    class B(A):
        def add(self, x):
            super(B, self).add(x)
    b = B()
    b.add(2)  # 3
    

    返回值

    无。

    以下展示了使用 super 函数的实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    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')
    

    执行结果:

    Parent
    Child
    HelloWorld from Parent
    Child bar fuction
    I'm the parent.
    

    Python Tuple(元组) tuple()方法

    描述

    Python 元组 tuple() 函数将列表转换为元组。

    tuple()方法语法:

    tuple( seq )

    参数

    seq – 要转换为元组的序列。

    返回值

    返回元组。

    以下实例展示了 tuple()函数的使用方法:

    实例 1

    >>>tuple([1,2,3,4])
     
    (1, 2, 3, 4)
     
    >>> tuple({1:2,3:4})    #针对字典 会返回字典的key组成的tuple
     
    (1, 3)
     
    >>> tuple((1,2,3,4))    #元组会返回元组自身
     
    (1, 2, 3, 4)
    

    实例 2

    #!/usr/bin/python
     
    aList = [123, 'xyz', 'zara', 'abc'];
    aTuple = tuple(aList)
     
    print "Tuple elements : ", aTuple
    

    以上实例输出结果为:

    Tuple elements :  (123, 'xyz', 'zara', 'abc')
    

    Python type() 函数

    描述

    type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。
    isinstance() 与 type() 区别:
    type() 不会认为子类是一种父类类型,不考虑继承关系。
    isinstance() 会认为子类是一种父类类型,考虑继承关系。
    如果要判断两个类型是否相同推荐使用 isinstance()。

    以下是 type() 方法的语法:

    type(object)
    type(name, bases, dict)

    参数

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

    返回值

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

    以下展示了使用 type 函数的实例:

    # 一个参数实例
    >>> type(1)
    <type 'int'>
    >>> type('runoob')
    <type 'str'>
    >>> type([2])
    <type 'list'>
    >>> type({0:'zero'})
    <type 'dict'>
    >>> x = 1          
    >>> type( x ) == int    # 判断类型是否相等
    True
     
    # 三个参数
    >>> class X(object):
    ...     a = 1
    ...
    >>> X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
    >>> X
    <class '__main__.X'>
    type() 与 isinstance()区别:
    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
    

    type() 与 isinstance()区别:

    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
    

    Python unichr() 函数

    描述

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

    以下是 unichr() 方法的语法:

    unichr(i)

    参数

    i – 可以是10进制也可以是16进制的形式的数字。

    返回值

    返回 unicode 的字符。

    以下展示了使用 unichr() 方法的实例:

    >>>unichr(97)
    u'a'
    >>> unichr(98)
    u'b'
    >>> unichr(99)
    u'c'
    

    Python unicode() 函数

    unicode()

    Python vars() 函数

    描述

    vars() 函数返回对象object的属性和属性值的字典对象。

    vars() 函数语法:

    vars([object])

    参数

    object – 对象

    返回值

    返回对象object的属性和属性值的字典对象,如果没有参数,就打印当前调用位置的属性和属性值 类似 locals()。

    以下实例展示了 vars() 的使用方法:

    >>>print(vars())
    {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
    >>> class Runoob:
    ...     a = 1
    ... 
    >>> print(vars(Runoob))
    {'a': 1, '__module__': '__main__', '__doc__': None}
    >>> runoob = Runoob()
    >>> print(vars(runoob))
    {}
    

    Python xrange() 函数

    描述

    xrange() 函数用法与 range 完全相同,所不同的是生成的不是一个数组,而是一个生成器。

    xrange 语法:

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

    参数说明:

    start: 计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0, 5)
    stop: 计数到 stop 结束,但不包括 stop。例如:xrange(0, 5) 是 [0, 1, 2, 3, 4] 没有 5
    step:步长,默认为1。例如:xrange(0, 5) 等价于 xrange(0, 5, 1)

    返回值

    返回生成器。

    以下实例展示了 xrange 的使用方法:

    >>>xrange(8)
    xrange(8)
    >>> list(xrange(8))
    [0, 1, 2, 3, 4, 5, 6, 7]
    >>> range(8)                 # range 使用
    [0, 1, 2, 3, 4, 5, 6, 7]
    >>> xrange(3, 5)
    xrange(3, 5)
    >>> list(xrange(3,5))
    [3, 4]
    >>> range(3,5)               # 使用 range
    [3, 4]
    >>> xrange(0,6,2)
    xrange(0, 6, 2)              # 步长为 2
    >>> list(xrange(0,6,2))
    [0, 2, 4]
    >>>
    

    Python3 zip() 函数

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

    zip 语法:

    zip([iterable, …])

    参数说明:

    iterabl – 一个或多个迭代器;

    返回值

    返回一个对象。

    以下实例展示了 zip 的使用方法:

    >>>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]
    >>>
    

    Python import() 函数

    描述

    import() 函数用于动态加载类和函数 。
    如果一个模块经常变化就可以使用 import() 来动态载入。

    import 语法:

    import(name[, globals[, locals[, fromlist[, level]]]])

    参数说明:

    name – 模块名

    返回值

    返回元组列表。

    以下实例展示了 import 的使用方法:

    a.py 文件代码:

    #!/usr/bin/env python    
    #encoding: utf-8  
     
    import os  
     
    print ('在 a.py 文件中 %s' % id(os))
    

    test.py 文件代码:

    #!/usr/bin/env python    
    #encoding: utf-8  
     
    import sys  
    __import__('a')        # 导入 a.py 模块
    

    执行 test.py 文件,输出结果为:

    在 a.py 文件中 4394716136
    

    Python exec 内置语句

    描述

    exec 执行储存在字符串或文件中的Python语句,相比于 eval,exec可以执行更复杂的 Python 代码。
    需要说明的是在 Python2 中exec不是函数,而是一个内置语句(statement),但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。

    以下是 exec 的语法:

    exec obj

    参数

    obj – 要执行的表达式。

    返回值
    exec 返回值永远为 None。

    以下展示了使用 exec 的实例:

    实例 1

    >>>exec 'print "Hello World"'
    Hello World
    # 单行语句字符串
    >>> exec "print 'runoob.com'"
    runoob.com
     
    #  多行语句字符串
    >>> exec """for i in range(5):
    ...   print "iter time: %d" % i
    ... """
    iter time: 0
    iter time: 1
    iter time: 2
    iter time: 3
    iter time: 4
    

    实例 2

    x = 10
    expr = """
    z = 30
    sum = x + y + z
    print(sum)
    """
    def func():
        y = 20
        exec(expr)
        exec(expr, {'x': 1, 'y': 2})
        exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
        
    func()
    

    输出结果:

    60
    33
    34
    

    其余参考原文
    菜鸟教程

    展开全文
  • prime§, 其中函数prime当用户传入参数p为素数时返回True,否则返回False. PrimeSum(m,n),函数PrimeSum返回区间[m, n]内所有素数的和。 题目保证用户传入的参数1<=m<n。 函数接口定义: 在这里描述函数接口: ...

    使用函数求素数和

    prime§, 其中函数prime当用户传入参数p为素数时返回True,否则返回False.
    PrimeSum(m,n),函数PrimeSum返回区间[m, n]内所有素数的和。
    题目保证用户传入的参数1<=m<n。

    函数接口定义:

    在这里描述函数接口:
    prime(p),返回True表示p是素数,返回False表示p不是素数
    PrimeSum(m,n),函数返回素数和
    

    裁判测试程序样例:

    
    /* 请在这里填写答案 */
    
    m,n=input().split()
    m=int(m)
    n=int(n)
    print(PrimeSum(m,n))
    

    输入样例:

    在这里给出一组输入。例如:

    1 10
    

    输出样例:

    在这里给出相应的输出。例如:

    17
    

    思路:

    判断素数相加。

    代码如下:

    def isPrime(num):
        num=int(num)
        for i in range(2,num):
            if num%i==0 :
                return False
        if(num!=1):
            return True
    def PrimeSum(a,b):
        sum=0
        for i in range(a,b+1):
            if isPrime(i):
                sum+=i
        return sum      
    
    展开全文
  • Java函数式编程详解

    万次阅读 多人点赞 2019-05-05 21:46:49
    Java从1.8以后引入了函数式编程,这是很大的一个改进。函数式编程的优点在提高编码的效率,增强代码的可读性。本文历时两个多月一点点写出来,即作为心得,亦作为交流。 1.Java函数式编程的语法: 使用Consumer...

    Java从1.8以后引入了函数式编程,这是很大的一个改进。函数式编程的优点在提高编码的效率,增强代码的可读性。本文历时两个多月一点点写出来,即作为心得,亦作为交流。

    1.Java函数式编程的语法:

    使用Consumer作为示例,它是一个函数式接口,包含一个抽象方法accept,这个方法只有输入而无输出也就是说这个方法无返回值。 
    现在我们要定义一个Consumer接口的实例化对象,传统的方式是这样定义的:

    public static void main(String[] args) {
            //JDK1.8版本之前的做法
            Consumer<Integer> con = new Consumer<Integer>() {
                @Override
                public void accept(Integer t) {
                    System.out.println(t);
                }
            };
            //调用方法
            con.accept(3);
        }

    这里可以打印出3.

    上面是JDK1.8以前的做法,在1.8以后引入函数式的编程可以这样写:

    public static void main(String[] args) {
            //第一种写法:
            Consumer<Integer> con = (param) -> {System.out.println(param);}; 
            //第二种写法:
            Consumer<Integer> con1 = (param) -> System.out.println(param);
            //第三种写法:
            Consumer<Integer> con2 = System.out::println;
            
            con2.accept(3);
        }

    上面的con、con1、con2这个Consumer对象的引用照样可以打印出3.

    在上面的第二种写法是第一种写法的精简,但是只有在函数题中只有一条语句时才可以这么使用,做进一步的简化。

    在上面的第三种写法是对第一、二种写法的进一步精简,由于第三种写法只是进行打印,调用了System.out中的println静态方法对输入参数直接进行打印。它表示的意思就是针对输入的参数将其调用System.out中的静态方法println进行打印。

    上面已说明,函数式编程接口都只有一个抽象方法,因此在采用这种写法时,编译器会将这段函数编译后当作该抽象方法的实现。 
    如果接口有多个抽象方法,编译器就不知道这段函数应该是实现哪个方法的了。 
    因此,=  后面的函数体我们就可以看成是accept函数的实现。

    输入:-> 前面的部分,即被()包围的部分。此处只有一个输入参数,实际上输入是可以有多个的,如两个参数时写法:(a, b);当然也可以没有输入,此时直接就可以是()。
    函数体:->后面的部分,即被{}包围的部分;可以是一段代码。
    输出:函数式编程可以没有返回值,也可以有返回值。如果有返回值时,需要代码段的最后一句通过return的方式返回对应的值。但是Consumer这个函数式接口不能有具体的返回值。

    Java 8 中我们可以通过 `::` 关键字来访问类的构造方法,对象方法,静态方法。

    好了,到这一步就可以感受到函数式编程的强大能力。 
    通过最后一段代码,我们可以简单的理解函数式编程,Consumer接口直接就可以当成一个函数了,这个函数接收一个输入参数,然后针对这个输入进行处理;当然其本质上仍旧是一个对象,但我们已经省去了诸如老方式中的对象定义过程,直接使用一段代码来给函数式接口对象赋值。 
    而且最为关键的是,这个函数式对象因为本质上仍旧是一个对象,因此可以做为其它方法的参数或者返回值,可以与原有的代码实现无缝集成!


    2.Java函数式接口

    java.util.function.Consumer;
    java.util.function.Function;
    java.util.function.Predicate;

    2.1 Consumer是一个函数式编程接口; 顾名思义,Consumer的意思就是消费,即针对某个东西我们来使用它,因此它包含有一个有输入而无输出(无返回值)的accept接口方法; 
    除accept方法,它还包含有andThen这个方法; 

    JDK源码定义如下:

    default Consumer<T> andThen(Consumer<? super T> after) {
            Objects.requireNonNull(after);
            return (T t) -> { accept(t); after.accept(t); };

     }

    andThen这个方法是作用是:指定在调用当前Consumer后是否还要调用其它的Consumer; 

    public static void main(String[] args) {
            //定义第一个Consumer
            Consumer<Integer> consumer1 = (param) -> {System.out.println(param);};
            
            //定义第二个Consumer
            Consumer<Integer> consumer2 = (param) -> {System.out.println(param * param);};
            
            //consumer1可以连续的调用自己
            //consumer1.andThen(consumer1).andThen(consumer1).accept(3);
            //打印出 3 3 3
            
            //consumer1可以调用自己后调用consumer2
            consumer1.andThen(consumer1).andThen(consumer2).accept(3);
            //打印出3 3 9
        }

    注意:当一个Consumer接口调用另外一个Consumer对象时两个Counsumer对象的泛型必须一致。

    2.2  Function也是一个函数式编程接口;它代表的含义是“函数”,它是个接受一个参数并生成结果的函数,而函数经常是有输入输出的,因此它含有一个apply方法,包含一个输入与一个输出; 
    除apply方法外,它还有compose与andThen及indentity三个方法,其使用见下述示例;

    apply的用法:

    public static void main(String[] args) {
            Function<Integer, Integer> fun = res -> res + 1;
            Integer  i = fun.apply(2);
            System.out.println(i);
    }

    上面打印出2。

    Function编程接口有两个泛型Function<T, R> T表示:函数的输入类型,R表示:函数的输出类型。

    compose的用法:

    JDK源码定义:

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
            Objects.requireNonNull(before);
            return (V v) -> apply(before.apply(v));

     }

    public static void main(String[] args) {
            Function<Integer, Integer> fun = res -> res + 1;
            Function<Integer, Integer> fun1 = res -> res * 10;
            Integer i = (Integer) fun.compose(fun1).apply(2);
            System.out.println(i);
    }

    上面打印出21;

    上面表示了fun2接收到2以后先计算,然后将fun2计算的结果再交给fun再计算。

    andThen方法的用法:

    JDK源码定义:

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
            Objects.requireNonNull(after);
            return (T t) -> after.apply(apply(t));

     }

    public static void main(String[] args) {
            Function<Integer, Integer> fun = res -> res + 1;
            Function<Integer, Integer> fun1 = res -> res * 10;
            Integer i = (Integer) fun.andThen(fun1).apply(3);
            System.out.println(i);
     }

    上面打印出40

    上面表示了fun先计算得到4,然后将计算结果4再给fun1计算得到40;

    indentity方法的用法:

    JDK源码定义:

    static <T> Function<T, T> identity() {
            return t -> t;
     }

    public static void main(String[] args) {
            System.out.println(Function.identity().apply("总分"));

     }

    上面打印出“总分“;就是说传入什么参数输出什么参数。

    2.3 Predicate为函数式接口,predicate的中文意思是“断定”,即判断的意思,判断某个东西是否满足某种条件; 因此它包含test方法,根据输入值来做逻辑判断,其结果为True或者False。 

    test方法的用法:

    JDK源码定义: boolean test(T t);

    public static void main(String[] args) {
            Predicate<String> pre = res -> res.equals("1234");
            boolean rest = pre.test("1234");
            System.out.println(rest);
     }

    上面打印出true。

    and方法的用法:

    JDK源码定义:

    default Predicate<T> and(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) && other.test(t);
     }

    public static void main(String[] args) {
            Predicate<String> pre = res -> res.equals("1234");
            Predicate<String> pre1 = res -> res.equals("1234");
            Predicate<String> pre3 = res -> res.equals("1234");
            boolean rest = pre.and(pre1).test("1234");
            boolean rest1 = pre.and(pre1).test("12341");
            System.out.println(rest);
            System.out.println(rest1); 

    }
    上面先打印出true,后打印出false

    根据源码,"1234"先和pre比较,如果为true,再和pre1比较。不为true直接返回false,不再和pre1比较。当“1234”和pre比较后为true,再和pre1比较结果为true,所以最终返回true。

    negate()的用法:

    JDK源码定义:

    default Predicate<T> negate() {
            return (t) -> !test(t);
     }

    public static void main(String[] args) {
            Predicate<String> pre = res -> res.equals("1234");
            boolean rest = pre.negate().test("1234");
            System.out.println(rest);
    }

    上面打印出false,上面的意思是如果比较的结果是true,那么返回false,如果为false,就返回true。

    or的方法的用法:

    JDK源码定义:

    default Predicate<T> or(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) || other.test(t);
    }

    public static void main(String[] args) {
            Predicate<String> pre = res -> res.equals("1234");
            Predicate<String> pre1 = res -> res.equals("12341");
            boolean rest = pre.or(pre1).test("12341");
            System.out.println(rest);
     }

    上面打印出true;

    or方法的意思是:只要一个为true就返回true。

    isEqual方法用法:

    JDK源码定义:

    static <T> Predicate<T> isEqual(Object targetRef) {
            return (null == targetRef)
                    ? Objects::isNull
                    : object -> targetRef.equals(object);
     }

    public static void main(String[] args) {
            System.out.println(Predicate.isEqual("12345").test("12345"));

    }

    上面打印出true;isEqual里的参数是要比较的目标对象。

    3.函数式编程接口的使用

    通过Stream以及Optional两个类,可以进一步利用函数式接口来简化代码。

    3.1 Stream

    Stream可以对多个元素进行一系列的操作,也可以支持对某些操作进行并发处理。

    3.1.1 Stream对象的创建

    Stream对象的创建途径有以下几种:

    a. 创建空的Stream对象

    Stream str = Stream.empty();

    b. 通过集合类中的stream或者parallelStream方法创建;

    List<String> list = Arrays.asList("a", "b", "c", "d");
    Stream listStream = list.stream(); //获取串行的Stream对象
    Stream parallelListStream = list.parallelStream(); //获取并行的Stream对象  

    c. 通过Stream中的of方法创建:

    Stream s = Stream.of("test");

    Stream s1 = Stream.of("a", "b", "c", "d");

    d. 通过Stream中的iterate方法创建: 
        iterate方法有两个不同参数的方法:

    public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f);  
    public static<T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)
    其中第一个方法将会返回一个无限有序值的Stream对象:它的第一个元素是seed,第二个元素是f.apply(seed); 第N个元素是f.apply(n-1个元素的值);生成无限值的方法实际上与Stream的中间方法类似,在遇到中止方法前一般是不真正的执行的。因此无限值的这个方法一般与limit等方法一起使用,来获取前多少个元素。 
    当然获取前多少个元素也可以使用第二个方法。 
    第二个方法与第一个方法生成元素的方式类似,不同的是它返回的是一个有限值的Stream;中止条件是由hasNext来断定的。
    第二种方法的使用示例如下:

    /**
     * 本示例表示从1开始组装一个序列,第一个是1,第二个是1+1即2,第三个是2+1即3..,直接10时中止;
     * 也可简化成以下形式:
     *        Stream.iterate(1,
     *        n -> n <= 10,
     *        n -> n+1).forEach(System.out::println);
     * 写成以下方式是为简化理解
     */
    Stream.iterate(1,
            new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) {
                    return integer <= 10;
                }
            },
        new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer+1;
            }
    }).forEach(System.out::println);

    e. 通过Stream中的generate方法创建 
    与iterate中创建无限元素的Stream类似,不过它的每个元素与前一元素无关,且生成的是一个无序的队列。也就是说每一个元素都可以随机生成。因此一般用来创建常量的Stream以及随机的Stream等。 
    示例如下:

    /**
     * 随机生成10个Double元素的Stream并将其打印
     */
    Stream.generate(new Supplier<Double>() {
        @Override
        public Double get() {
            return Math.random();
        }
    }).limit(10).forEach(System.out::println);

    //上述写法可以简化成以下写法:
    Stream.generate(() -> Math.random()).limit(10).forEach(System.out::println);


    f. 通过Stream中的concat方法连接两个Stream对象生成新的Stream对象 
    这个比较好理解不再赘述。

    3.1.2 Stream对象的使用
    Stream对象提供多个非常有用的方法,这些方法可以分成两类: 
    中间操作:将原始的Stream转换成另外一个Stream;如filter返回的是过滤后的Stream。 
    终端操作:产生的是一个结果或者其它的复合操作;如count或者forEach操作。

    其清单如下所示,方法的具体说明及使用示例见后文。 
    所有中间操作:

    所有的终端操作:

    下面就几个比较常用的方法举例说明其用法:

    3.1.2.1 filter
    用于对Stream中的元素进行过滤,返回一个过滤后的Stream 
    其方法定义如下:

    Stream<T> filter(Predicate<? super T> predicate);

    使用示例:

    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
    //查找所有包含t的元素并进行打印
    s.filter(n -> n.contains("t")).forEach(System.out::println);

    3.1.2.2 map
    元素一对一转换。 
    它接收一个Funcation参数,用其对Stream中的所有元素进行处理,返回的Stream对象中的元素为Function对原元素处理后的结果 
    其方法定义如下:

    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

    示例,假设我们要将一个String类型的Stream对象中的每个元素添加相同的后缀.txt,如a变成a.txt,其写法如下:

    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
    s.map(n -> n.concat(".txt")).forEach(System.out::println);

    3.1.2.3 flatMap
    元素一对多转换:对原Stream中的所有元素使用传入的Function进行处理,每个元素经过处理后生成一个多个元素的Stream对象,然后将返回的所有Stream对象中的所有元素组合成一个统一的Stream并返回; 
    方法定义如下:

    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

    示例,假设要对一个String类型的Stream进行处理,将每一个元素的拆分成单个字母,并打印:

    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
    s.flatMap(n -> Stream.of(n.split(""))).forEach(System.out::println);

    3.1.2.4 takeWhile
    方法定义如下:

    default Stream<T> takeWhile(Predicate<? super T> predicate)

    如果Stream是有序的(Ordered),那么返回最长命中序列(符合传入的Predicate的最长命中序列)组成的Stream;如果是无序的,那么返回的是所有符合传入的Predicate的元素序列组成的Stream。 
    与Filter有点类似,不同的地方就在当Stream是有序时,返回的只是最长命中序列。 
    如以下示例,通过takeWhile查找”test”, “t1”, “t2”, “teeeee”, “aaaa”, “taaa”这几个元素中包含t的最长命中序列:

    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa", "taaa");
    //以下结果将打印: "test", "t1", "t2", "teeeee",最后的那个taaa不会进行打印 
    s.takeWhile(n -> n.contains("t")).forEach(System.out::println);

    3.1.2.5 dropWhile
    与takeWhile相反,如果是有序的,返回除最长命中序列外的所有元素组成的Stream;如果是无序的,返回所有未命中的元素组成的Stream;其定义如下:

    default Stream<T> dropWhile(Predicate<? super T> predicate)

    如以下示例,通过dropWhile删除”test”, “t1”, “t2”, “teeeee”, “aaaa”, “taaa”这几个元素中包含t的最长命中序列:

    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa", "taaa");
    //以下结果将打印:"aaaa", "taaa"  
    s.dropWhile(n -> n.contains("t")).forEach(System.out::println);

    3.1.2.6 reduce与collect
    关于reduce与collect由于功能较为复杂,在后续将进行单独分析与学习,此处暂不涉及。

    3.2 Optional用于简化Java中对空值的判断处理,以防止出现各种空指针异常。 
    Optional实际上是对一个变量进行封装,它包含有一个属性value,实际上就是这个变量的值。

    3.2.1 Optional对象创建
    它的构造函数都是private类型的,因此要初始化一个Optional的对象无法通过其构造函数进行创建。它提供了一系列的静态方法用于构建Optional对象:

    3.2.1.1 empty
    用于创建一个空的Optional对象;其value属性为Null。 
    如:

    Optional o = Optional.empty();

    3.2.1.2 of
    根据传入的值构建一个Optional对象; 
    传入的值必须是非空值,否则如果传入的值为空值,则会抛出空指针异常。 
    使用:

    o = Optional.of("test"); 
    1
    3.2.1.3 ofNullable
    根据传入值构建一个Optional对象 
    传入的值可以是空值,如果传入的值是空值,则与empty返回的结果是一样的。

    3.2.2 方法
    Optional包含以下方法:

    3.2.3 使用场景
    常用的使用场景如下:

    3.2.3.1 判断结果不为空后使用
    如某个函数可能会返回空值,以往的做法:

    String s = test();
    if (null != s) {
        System.out.println(s);
    }

    现在的写法就可以是:

    Optional<String> s = Optional.ofNullable(test());
    s.ifPresent(System.out::println);

    乍一看代码复杂度上差不多甚至是略有提升;那为什么要这么做呢? 
    一般情况下,我们在使用某一个函数返回值时,要做的第一步就是去分析这个函数是否会返回空值;如果没有进行分析或者分析的结果出现偏差,导致函数会抛出空值而没有做检测,那么就会相应的抛出空指针异常! 
    而有了Optional后,在我们不确定时就可以不用去做这个检测了,所有的检测Optional对象都帮忙我们完成,我们要做的就是按上述方式去处理。

    3.2.3.2 变量为空时提供默认值
    如要判断某个变量为空时使用提供的值,然后再针对这个变量做某种运算; 
    以往做法:

    if (null == s) {
        s = "test";
    }
    System.out.println(s);

    现在的做法:

    Optional<String> o = Optional.ofNullable(s);
    System.out.println(o.orElse("test"));

    3.2.3.3 变量为空时抛出异常,否则使用
    以往写法:

    if (null == s) {
        throw new Exception("test");
    }
    System.out.println(s);


    现在写法:

    Optional<String> o = Optional.ofNullable(s);
    System.out.println(o.orElseThrow(()->new Exception("test")));
     

    展开全文
  • Python列表排序 list.sort方法和内置函数sorted

    万次阅读 多人点赞 2019-05-18 15:17:54
    Python列表排序 list.sort方法和内置函数sorted 很多时候我们获取到一个列表后,这个列表并不满足我们的需求,我们需要的是一个有特殊顺序的列表. 这时候就可以使用list.sort方法和内置函数sorted,本文就是介绍list....

    Python列表排序 list.sort方法和内置函数sorted

    很多时候我们获取到一个列表后,这个列表并不满足我们的需求,我们需要的是一个有特殊顺序的列表.

    这时候就可以使用list.sort方法和内置函数sorted,本文就是介绍list.sort方法和sorted内置函数的使用方法和区别.

    一、list.sort方法

    list.sort方法会就地排序列表,也就是说不会把原列表复制一份。这也是这个方法的返回值是None的原因,提醒您本方法不会新建一个列表。

    在这种情况下返回None其实是Python的一个惯例:如果一个函数或者方法对对象进行的是就地改动,那它就应该返回 None,好让调用者知道传入的参数发生了变动,而且并未产生新的对象。

    来看一下代码:

    # coding=utf-8
    list_a = [1, 2, 8, 3, 7, 9, 5, 7]
    # sort()方法没有返回值
    list_b = list_a.sort()
    print("list_a: ", list_a)
    print('list_b: ', list_b)

    运行结果:

    list_a:  [1, 2, 3, 5, 7, 7, 8, 9]
    list_b:  None

    用返回None来表示就地改动这个惯例有个弊端,那就是调用者无法将其串联起来。而返回一个新对象的方法则正好相反,它们可以链式调用,从而形成连贯接口。

    二、sorted内置函数

    与 list.sort 相反,内置函数sorted会新建一个列表作为返回值。

    这个方法可以接受任何形式的可迭代对象作为参数,甚至包括不可变序列或生成器,而不管sorted接受的是怎样的参数,它最后都会返回一个列表。

    代码示例:

    list_c = [1, 2, 8, 3, 7, 9, 5, 7]
    # sorted内置函数会返回一个排序后的新列表
    list_d = sorted(list_c)
    print("list_c: ", list_c)
    print('list_d: ', list_d)

    运行结果:

    list_c:  [1, 2, 8, 3, 7, 9, 5, 7]
    list_d:  [1, 2, 3, 5, 7, 7, 8, 9]

    可以看到,使用内置函数sorted时,返回了一个新的列表,而原列表没有发生改变。

    这有两种好处:

    1.如果我们即需要使用原列表,也需要使用排序后的列表,或者说我们要将一个非列表的可迭代对象排序成列表,sorted都可以做到

    2.有返回值时,我们可以进行链式调用

    # 可以对非列表的可迭代对象排序生成列表
    str_e = 'python'
    list_e = sorted(str_e)
    print(list_e)
    
    # 链式调用
    str_f = '-'.join(sorted(str_e)).upper().split('-')
    print(str_f)
    

    运行结果:

    ['h', 'n', 'o', 'p', 't', 'y']
    ['H', 'N', 'O', 'P', 'T', 'Y']

    三、关键字参数key和reverse

    不管是 list.sort 方法还是 sorted 函数,都有两个可选的关键字参数:

    key
    接收一个只有一个参数的函数,这个函数会被用在序列里的每一个元素上,所产生的结果将是排序算法依赖的对比关键字。

    比如说,在对一些字符串排序时,可以用 key=str.lower 来实现忽略大小写的排序,或者是用 key=len 进行基于字符串长度的排序。key的默认值是恒等函数,也就是默认用元素自己的值来排序。

    reverse:

    如果被设定为 True,被排序的序列里的元素会以降序输出(也就是说把最大值当作最小值来排序),reverse的默认值是 False.

    phone = ('HUAWEI', 'OPPO', 'MI', 'MEIZU', 'VIVO')
    # 按长度进行排序
    phone_list = sorted(phone, key=len)
    print(phone_list)
    
    phone_list_re = sorted(phone, key=len, reverse=True)
    print(phone_list_re)

    运行结果:

    ['MI', 'OPPO', 'VIVO', 'MEIZU', 'HUAWEI']
    ['HUAWEI', 'MEIZU', 'OPPO', 'VIVO', 'MI']

    上面的代码中,第一次排序新建了一个按照长度排序的字符串列表。第二次排序是将按长度排序由升序变成了降序。

    细心的您应该可以发现,第二次的结果并不是第一次排序的结果的完全翻转。

    OPPO和VIVO的长度都是4,reverse=True后,它们的相对位置跟第一次排序是一样的。这是什么原因呢?

    sorted和list.sort背后的排序算法都是Timsort,它是一种自适应算法,会根据原始数据的顺序特点交替使用插入排序和归并排
    序,以达到最佳效率。

    Python的排序算法Timsort是稳定的(知道这一点就可以了),意思是就算两个元素比不出大小,在每次排序的结果里它们的相对位置是固定的。

    因为用到的排序算法是稳定的,也就是说在长度一样时,OPPO和VIVO的相对位置不会改变。

    关于list.sort()方法和sorted内置函数的使用,现在已经掌握了~

     

     

    展开全文
  • render函数什么,怎么用

    万次阅读 2019-02-16 14:23:25
    render函数什么  简单的说,在vue中我们使用模板HTML语法组建页面的,使用render函数我们可以用js语言来构建DOM  因为vue是虚拟DOM,所以在拿到template模板时也要转译成VNode的函数,而用render函数构建DOM,...
  • C语言windows.h库的常用函数(三)

    千次阅读 多人点赞 2019-09-07 21:57:00
    SetCursorPos函数 用途 SetCursorPos函数是windows.h库中用来设置指针位置的函数,使用该函数鼠标指针将会直接跳至指定坐标位置 参数 SetCursorPos函数拥有x和y两个整型参数,作为鼠标指针的坐标位置(其中0,0坐标...
  • 机器学习当中I函数代表什么意思

    千次阅读 多人点赞 2018-08-13 16:10:51
    机器学习算法推导当中,有的时候能看到一个函数 ,这个函数代表什么意思?  代表的是指示函数(indicator function)。 它的含义是:当输入为True的时候,输出为1,输入为False的时候,输出为0。 例如: ,...
  • C语言入门 函数调用 main函数 int main 是什么

    千次阅读 多人点赞 2020-07-25 23:56:40
    目录引入函数main 函数其他 引入 学任何编程语言的时候,大家应该写的第一个程序都是输出“Hello, world!”。 我学python,Java的时候都是,现在学C语言也不例外。 于是就有了以下代码: int main(){ cout <<...
  • 1. 函数定义和调用 1-1 常见的函数定义和调用 匿名函数: function() {}; // 会报错, var fn = function() {}; // 不会报错 fn(); 普通函数: function myFn() {}; myFn(); 1-2 错误的直接调用 ...
  • def isPrime(num): if num == 0: return 'False' elif num == 1: return 'False' elif num == 2: return 'True' elif num > 2: for i in range(2,num): if num % i != 0: return 'True' .
  • 什么是sign函数(符号函数

    万次阅读 多人点赞 2019-06-16 11:34:51
    sign函数(符号函数) 在logistic回归中,利用sigmoid函数实现,当x>0,y=1;当x<0时,y=0; σ(x)=11+ex\sigma(x) = \frac{1}{1+e^x}σ(x)=1+ex1​ tanh函数: tanh(x)=ex−e−xex+e−xtanh(x)=\frac{e^x-...
  • javaScript学习笔记(一)js基础

    万次阅读 多人点赞 2018-09-21 10:07:18
    java则使用什么类型的变量就要定义什么类型的。 9、检测数据类型: typeof(value); 或者typeof value; 返回这个变量的类型. 说明 : 同一个变量, 可以进行不同类型的数据赋值. 10、算术运算符 + - * / % ++ -- 注意:...
  • logits表示网络的直接输出 。没经过sigmoid或者softmax的概率化。from_logits=False就表示把已经概率化了的输出,重新映射回原值。log(p/(1-p))
  • ;(function(){ //这应该是一个某系统的插件js //具体功能代码。。。 })(); ...从语法上来开,Javascript中分号表示语句结束,在开头加上,...叹号是逻辑运算符,是“非”的意思,常见这种写法 if(!true){};而将运算符加
  • Python中的True和False与bool()函数吗?

    千次阅读 2019-04-16 16:55:36
    首先我们应该知道True和False都是bool类的对象,有关True和False不太清楚的可以参考Python中is和==的区别以及is None 第四部分, 这里不再详细解释。下面我们来看bool函数。 bool([x]) 作用: 将x转换为Boolean...
  • 回文:把相同的字符串颠倒过来,产生首尾回环,叫做回文。 例如:1234321、1221、1。 注意:单个字符也是回文。 下面给出两个版本的判断字符串是否是回文的方法。...方法一:递归实现判断一个... return true; if
  • 函数注释示例: def f(ham: 42, eggs: int = 'spam') -&gt; "Nothing to see here": print("函数注释", f.__annotations__) print("参数值打印", ham, eggs) print(type(ham),...
  • 什么是默认构造函数

    千次阅读 多人点赞 2017-05-29 01:04:40
    对于C++默认构造函数,我曾经有两点误解: 类如果没有定义任何的构造函数,那么编译器(一定会!)将为类定义一个合成的默认构造函数。 合成默认构造函数会初始化类中所有的数据成员。 第一个误解来自于我学习C++的第...
  • #质数是大于1的正整数,质数只能被1和它本身整除 def isPrime(): while True: num=eval(input(‘请输入大于1的整数:’)) ...=3:return True #定义一个函数,执行到return就不执行下面的语句了 elif nu.
  • 定义一个函数,判断year是否是闰年,若是闰年返回true,否则返回false,代码如下 : def is_leap(year): year = int(year) if (year % 4 == 0) and (year % 100 != 0): return True elif year % 400 == 0: ...
  • Python中reverse与reverse=true

    万次阅读 多人点赞 2019-07-06 12:16:15
    排序 a = [2, 3, 1] a.sort(reverse=True) print(a) # [3, 2, 1] 没有排序 a = [2, 3, 1] a.reverse() print(a) # [1, 3, 2]
  • c++如下定义类函数后加冒号是什么意思 什么时候这么用 如 M( const char* in_file ):m_w(),m_object_morph(true) 这是对类成员初始化的意思,一般用于对父类成员初始化。 如果子类中有无参构造函数而而父类中...
  • Python中的id函数到底是什么

    万次阅读 2014-05-15 13:35:00
     print obj1 == obj2 #True    lst1=[1]  lst2=[1]  print lst1 is lst2 #False  print lst1 == lst2 #True    s1='abc'  s2='abc'  print s1 is s2 #True  print s1 == s2 #True    a=2 ...
  • #实现isPrime()函数,参数为整数,要有异常处理,如果是质数返回True,否则返回False def isPrime(n): if n < 2: return False else: for i in range(2,int(pow(n,0.5)+1)): if n % i == 0: ...
  • python 入门 guess 函数

    千次阅读 2018-05-21 10:00:00
    猜年龄限制次数,使用while函数和count计数器。 age_of_spencer = 28 count = 0 while True: if count == 2: break age = int(input("age:")) if age == age_of_spencer: print("you made it")...
  • 设计一个验证用户登录的函数,根据用户输入的口令是否正确,返回True或False 题目是廖雪峰老师的python教程中hashlib的练习。 本篇博文只是针对这一题目,没有做详细的介绍,如果看不懂可以在下面评论问我,我会及时...
  • 什么vue中data必须是一个函数

    万次阅读 多人点赞 2019-03-28 10:25:54
    本文从JavaScript原型链角度来解释为什么vue中的data必须是一个函数 VUE组件中的data必须是函数 类别引用数据类型 Object是引用数据类型,如果不用function返回,每个组件的data都是内存的同一个地址,一个数据...
  • 返回bool的函数无return时返回true还是false  #include bool f(){}int main(){if(f())printf("default return true!\n");elseprintf("default return false!\n");} 代码如上: 结果是什么? 在vs2008下,会是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,427,996
精华内容 971,198
关键字:

true函数是什么意思