精华内容
下载资源
问答
  • 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
    

    其余参考原文
    菜鸟教程

    展开全文
  • Python中的函数

    万次阅读 多人点赞 2018-10-30 12:30:23
    Python内置函数 函数式编程 匿名函数(lambda) 函数作为参数  返回函数(闭包) 装饰器 Python中内置的装饰器 偏函数 高阶函数 map reduce filter sorted 自定义函数 参数 默认参数 可变参数 关键字...

    目录

    Python内置函数

    函数式编程

    匿名函数(lambda)

    函数作为参数 

    返回函数(闭包)

    装饰器

    Python中内置的装饰器

    偏函数

    高阶函数

    map

    reduce

    filter

    sorted

    自定义函数

    参数

    默认参数

    可变参数

    关键字参数

    返回值


    函数是用于实现某一功能的接口,通过对函数传入参数,用来实现某一功能。

    Python内置函数

    相关文章:Python内置函数

    函数式编程

    匿名函数(lambda)

    普通函数

    >>def Sum(x,y):
    >>    return x+y
    >>Sum(2,3)
    5

    匿名函数

    >>Sum=lambda x,y:x+y        //冒号之前的是匿名函数的参数,冒号后面的是匿名函数的返回值
    >>Sum(2,3)
    5

    匿名函数的应用 

    >>def f(n):
    >>    return lambda x:x+n
    >>f=f(42)          #相当于 f=f(n)=42+n
    >>print(f(8))           
    50

    函数作为参数 

    def Sum(fun,x1,x2):
        return fun(x1,x2)
    def add(x1,x2):
        return x1+x2
    a=Sum(add,2,3)
    print(a)
    ## 5

    返回函数(闭包)

    高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回。

    def outer(a):               //外函数
        b=10
        def inner():            //内函数,
            return a+b          //内函数中用到了外函数的临时变量
        return inner            //返回内函数的应用
    demo=outer(5)               //demo 等于 内函数的引用
    demo()
    ##  15
    
    
    def outer(n):              //外函数
        def inner(a):          //内函数,接受参数
            return a**n        //调用外函数的参数
        return inner
    x=outer(2)(3)
    print(x)
    ## 9

    当我们调用 outer(5) 时,返回的并不是求和结果,而是内部 inner() 函数的引用,调用函数 demo() 时,才真正计算求和的结果:
    在这个例子中,我们在函数 outer() 中又定义了函数 inner(),并且,内部函数 inner() 可以引用外部函数 outer() 的参数和局部变量,当 outer() 返回函数 inne r时,相关参数和变量都保存在返回的函数中,这种称为 “ 闭包(Closure)”的程序结构拥有极大的威力。外部函数发现,自己的临时变量会在将来的内部函数中用到,自己在结束的时候,返回内部函数的同时,会把外函数的临时变量送给内函数绑定在一起。所以外函数已经结束了,调用内函数的时候仍然能够使用外函数的临时变量
     
    在内部函数中修改外部函数的变量:可以用 nonlocal 关键字声明这个变量, 表示这个变量不是局部变量空间的变量,需要向上一层变量空间找这个变量

    def outer(a):              //外函数
        b=10
        def inner():           //内函数,
            nonlocal b         //表示这个变量不是局部变量,需要向上一层变量空间找这个变量
            b=20               //修改外变量的临时参数
            return a+b         //内函数中用到了外函数的临时变量
        return inner           //返回内函数的引用
    demo=outer(5)              //demo 等于 内函数的引用
    demo()
    ###  25

    还有一点需要注意:使用闭包的过程中,一旦外函数被调用一次返回了内函数的引用,虽然每次调用内函数,是开启一个函数执行过后消亡,但是闭包变量实际上只有一份,每次开启内函数都在使用同一份闭包变量

    def outer(a):               //外函数
        def inner(b):           //内函数,
            nonlocal a          //表示这个变量不是局部变量,需要向上一层变量空间找这个变量
            a=a+b               //修改外变量的临时参数
            return a            //内函数中用到了外函数的临时变量
        return inner            //返回内函数的应用
    demo=outer(2)               //demo 等于 内函数的引用
    print( demo(3)  )
    ## 5
    print( demo(4) )
    ## 9

     !!!返回闭包时牢记一点:返回函数不要引用任何循环变量,或者后续会发生变化的变量。

    装饰器

    假如我们要增强一个函数的功能,但又不希望修改函数的定义,这种在代码运行期间动态增强功能的方式,称之为装饰器(Decorator)。本质上,decorator 就是一个返回函数的高阶函数,而传入参数又是要执行的函数,它在闭包的基础上多进行了几步。

    比如,我们现在要在函数调用前后记录时间,然后记录程序的运行时间。我们一般会想到的是在程序前后直接加入计时代码,但是这样往往需要修改函数的定义,所以一般不这样使用。

    def myfunc():
        startT=time.time()     #开始时间
        print("myfunc start.....")
        time.sleep(1)
        print("myfunc end....")
        endT=time.time()       #结束时间
        msecs=(endT-startT)*1000
        print("运行程序花费了 %f ms"%msecs)
    myfunc()

    所以,装饰器就出现了。我们如果要定义一个能记录程序运行时间的装饰器decorator,可以如下定义:

    from functools import wraps
    def deco(func):
        @wraps(func)              #不加这个的话 myfunc.__name__ 的值就变成了 wrapper
        def wrapper():
            startT=time.time()       #在执行函数的之前做的操作
            print("执行函数之前")
            func()
            print("执行函数之后")
            endT=time.time()          #在执行函数的之后做的操作
            msecs=(endT-startT)*1000
            print("运行程序花费了 %f ms"%msecs)
        return wrapper
    @deco                             # 相当于 myfunc=deco(myfunc)
    def myfunc():
        print("myfunc start.....")
        time.sleep(1)
        print("myfunc end....")
    
    myfunc()                  #实际上是在执行 wrapper()函数,也就是 deco(myfunc).wrapper()

     相关文章:Python函数装饰器

    Python中内置的装饰器

    @staticmethod : 类静态方法
       与成员方法的区别是没有self参数,并且可以在类不进行实例化的情况下调用
    @classmethod : 类方法
       与成员方法的区别在于所接收的第一个参数不是self(类实例的指针),而是cls (当前类的具体类型)
    @property : 属性方法
      将一个类方法转变成一个类属性,只读属性

    class A:
        def talk():
            print("talk")
     
    A.talk()   ###可以执行
    a=A()
    a.talk()  ###不可以执
     
     
    class A:
        def talk(self):
            print("talk")
     
    A.talk()   ###不可以执行
    a=A()
    a.talk()  ###可以执
     
    class A:
        @staticmethod
        def talk():
            print("talk")
    
    A.talk()   ###可以执行
    a=A()
    a.talk()  ###可以执行

    偏函数

    当函数的参数个数太多,需要简化时,可以使用 functools.partial 创建一个新的函数,这个新的函数可以固定住原函数的部分参数,从而在调用时更简单。这样的新函数叫做 偏函数
    例如 int() 函数可以把字符串转换为整数,当仅传入字符串时,int() 函数默认按十进制转换

    >>> int('12345')
    12345

    但int()函数还提供额外的base参数,默认值为10。如果传入base参数,就可以做N进制的转换:

    >>> int('12345', base=8)
    5349
    >>> int('12345', 16)
    74565

    当我们要转换大量的二进制字符串时,每次都传入int(x, base=2)非常麻烦,于是我们可以使用 funtools.partial

    >>> import functools
    >>> int2 = functools.partial(int, base=2)
    >>> int2('1000000')
    64
    >>> int2('1010101')
    85

    高阶函数

    map

    map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。

    >>> def f(x):
    ...     return x * x
    >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])                 ##返回一个Iteraotr
    >>>print ( list(r) )                                                               ## 变成一个list,然后打印出来
    [1, 4, 9, 16, 25, 36, 49, 64, 81]

    reduce

    reduce()把一个函数作用在一个序列[x1, x2, x3, ...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,返回一个整形,其效果就是:   reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

    >>> from functools import reduce
    >>> def fn(x, y):
    ...     return x * 10 + y
    ...
    >>> reduce(fn, [1, 3, 5, 7, 9])
    13579

    filter

    Python内建的filter()函数用于过滤序列。和map()类似,filter()也接收一个函数和一个序列。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素,最后返回一个 Iterator
     
    例如,在一个list中,删掉偶数,只保留奇数,可以这么写:

    >>>def is_odd(n):
        return n % 2 == 1
    >>>list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
    # 结果: [1, 5, 9, 15]

    sorted

    排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小。如果是数字,我们可以直接比较,但如果是字符串或者两个dict呢?直接比较数学上的大小是没有意义的,因此,比较的过程必须通过函数抽象出来。Python内置的sorted()函数可以实现对数据按照指定规则排序,它可以接收一个key函数来实现自定义的排序,还可以接收第三个参数 reverse=True来实现对数据的反向排序。
    例:

    >>> sorted(['bob', 'about', 'Zoo', 'Credit'])
    ['Credit', 'Zoo', 'about', 'bob']

    默认情况下,对字符串排序,是按照ASCII的大小比较的,由于'Z' < 'a',结果,大写字母Z会排在小写字母a的前面
    现在,我们提出排序应该忽略大小写,按照字母序排序。要实现这个算法,不必对现有代码大加改动,只要我们能用一个key函数把字符串映射为忽略大小写排序即可。忽略大小写来比较两个字符串,实际上就是先把字符串都变成大写(或者都变成小写),再比较。
    这样,我们给sorted传入key函数,即可实现忽略大小写的排序:

    >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
    ['about', 'bob', 'Credit', 'Zoo']

    要进行反向排序,不必改动key函数,可以传入第三个参数 reverse=True:

    >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
    ['Zoo', 'Credit', 'bob', 'about']

    自定义函数

    参数

    Python的函数定义非常简单,但灵活度却非常大。除了正常定义的必选参数外,还可以使用默认参数、可变参数和关键字参数,使得函数定义出来的接口,不但能处理复杂的参数,还可以简化调用者的代码。

    默认参数

    def  Max(x , y):
        if x>y:
            return x
        else:
            return y

    对于以上的代码,x和y参数还可以默认给出,但是如果要给定默认参数,第一个参数默认给定了的话,后面的参数也必须默认给定,或者就是后面的参数给定,但是第一个参数不给定

    def  Max(x=3 , y=6):
    def  Max(x ,   y=10):
    def  Max(x=10 , y):          ##这样不行,语法错误

    定义默认参数要牢记一点:默认参数必须指向不变对象!

    可变参数

    在Python函数中,还可以定义可变参数。顾名思义,可变参数就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是0个。
    我们以数学题为例子,给定一组数字a,b,c……,请计算a2 + b2 + c2 + ……
    一般做法

    def calc(numbers):
        sum=0
        for n in numbers:
            sum=sum+n*n
        return sum
    #在调用的时候,可以组装出一个list或tuple
    calc( [1,2,3] )
    或
    calc( (1,2,3) )

    可变函数做法

    def calc(*numbers):           ##定义了一个可变参数,在函数内部,参数numbers接收到的是一个tuple
        sum=0
        for n in numbers:
            sum=sum+n*n
        return sum
    ##  如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做:
    nums=[1,2,3,4,5,6]
    calc( *nums )
    ##  *nums表示把nums这个list的所有元素作为可变参数传进去

    关键字参数

    关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict

    def person(name,age,**kw):
        print('name:' , name , 'age:' , age , 'other:' , kw)
    person('xie' , 30 , city='beijing' , number='123456')
    ##   name: xie age: 30 other: {'city': 'beijing', 'number': '123456'}

    关键字参数有什么用?它可以扩展函数的功能。比如,在person函数里,我们保证能接收到name和age这两个参数,但是,如果调用者愿意提供更多的参数,我们也能收到。试想你正在做一个用户注册的功能,除了用户名和年龄是必填项外,其他都是可选项,利用关键字参数来定义这个函数就能满足注册的需求。
    和可变函数类似,关键字函数也可以先组装一个dict,然后传进去

    extra={'city':'beijing','number':'123456'}
    person('xie', 30 , **extra)

    **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数,kw将获得一个dict,注意kw获得的dict是extra的一份拷贝,对kw的改动不会影响到函数外的extra
     
    如果要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收city和job作为关键字参数。这种方式定义的函数如下

    def person(name,age,*,city,number):
           print(name,age,city,number)

    和关键字参数**kw不同,命名关键字参数需要一个特殊分隔符*,*后面的参数被视为命名关键字参数。
     
    在Python中定义函数,可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数,这5种参数都可以组合使用。但是请注意,参数定义的顺序必须是:必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
     
    多参数冗余处理,定义参数的时候,多设置用于接收多余参数的
     
    调用函数事,如果参数个数不对或者参数类型不对,pyhton解释器会抛出 TypeError 异常。

    返回值

    函数体内部的语句在执行时,一旦执行到return时,函数就执行完毕,并将结果返回。因此,函数内部通过条件判断和循环可以实现非常复杂的逻辑。
    如果没有return语句,函数执行完毕后也会返回结果,只是结果为None。return None可以简写为return

     

    展开全文
  • 7 Python中的函数

    千次阅读 2017-03-08 22:33:36
    7 Python中的函数 Python中的函数 7-1 Python之什么是函数 7-2 Python之调用函数 7-3 Python之编写函数 7-4 Python函数之返回多值 7-5 Python之递归函数 7-6 Python之定义默认参数 7-7 Python之定义可变参数7-1 ...

    7 Python中的函数

    7-1 Python之什么是函数

    Python之什么是函数


    我们知道圆的面积计算公式为:

    S = πr²

    当我们知道半径r的值时,就可以根据公式计算出面积。假设我们需要计算3个不同大小的圆的面积:

    r1 = 12.34
    r2 = 9.08
    r3 = 73.1
    s1 = 3.14 * r1 * r1
    s2 = 3.14 * r2 * r2
    s3 = 3.14 * r3 * r3

    当代码出现有规律的重复的时候,你就需要当心了,每次写3.14 * x * x不仅很麻烦,而且,如果要把3.14改成3.14159265359的时候,得全部替换。

    有了函数,我们就不再每次写s = 3.14 * x * x,而是写成更有意义的函数调用

    s = area_of_circle(x)

    ,而函数 area_of_circle 本身只需要写一次,就可以多次调用。

    抽象是数学中非常常见的概念。举个例子:

    计算数列的和,比如:1 + 2 + 3 + … + 100,写起来十分不方便,于是数学家发明了求和符号∑,可以把1 + 2 + 3 + … + 100记作:

    100
    ∑n
    n=1

    这种抽象记法非常强大,因为我们看到∑就可以理解成求和,而不是还原成低级的加法运算。

    而且,这种抽象记法是可扩展的,比如:

    100
    ∑(n²+1)
    n=1

    还原成加法运算就变成了:

    (1 x 1 + 1) + (2 x 2 + 1) + (3 x 3 + 1) + ... + (100 x 100 + 1)

    可见,借助抽象,我们才能不关心底层的具体计算过程,而直接在更高的层次上思考问题。

    写计算机程序也是一样,函数就是最基本的一种代码抽象的方式。

    Python不但能非常灵活地定义函数,而且本身内置了很多有用的函数,可以直接调用。


    7-2 Python之调用函数

    Python之调用函数


    Python内置了很多有用的函数,我们可以直接调用。

    要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数 abs,它接收一个参数。

    可以直接从Python的官方网站查看文档:
    http://docs.python.org/2/library/functions.html#abs

    也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。

    调用 abs 函数:

    >>> abs(100)
    100
    >>> abs(-20)
    20
    >>> abs(12.34)
    12.34

    调用函数的时候,如果传入的参数数量不对,会报TypeError的错误,并且Python会明确地告诉你:abs()有且仅有1个参数,但给出了两个:

    >>> abs(1, 2)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: abs() takes exactly one argument (2 given)

    如果传入的参数数量是对的,但参数类型不能被函数所接受,也会报TypeError的错误,并且给出错误信息:str是错误的参数类型:

    >>> abs('a')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: bad operand type for abs(): 'str'

    而比较函数 cmp(x, y) 就需要两个参数,如果 x

    >>> cmp(1, 2)
    -1
    >>> cmp(2, 1)
    1
    >>> cmp(3, 3)
    0

    Python内置的常用函数还包括数据类型转换函数,比如 int()函数可以把其他数据类型转换为整数:

    >>> int('123')
    123
    >>> int(12.34)
    12

    str()函数把其他类型转换成 str:

    >>> str(123)
    '123'
    >>> str(1.23)
    '1.23'
    

    任务

    sum()函数接受一个list作为参数,并返回list所有元素之和。请计算 1*1 + 2*2 + 3*3 + … + 100*100。

    答案:

    List1 = range(1, 101)
    List2 = []
    for x in List1:
        List2.append(x*x)
    print(sum(List2))

    7-3 Python之编写函数

    Python之编写函数


    在Python中,定义一个函数要使用 def 语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用 return 语句返回。

    我们以自定义一个求绝对值的 my_abs 函数为例:

    def my_abs(x):
        if x >= 0:
            return x
        else:
            return -x

    请注意,函数体内部的语句在执行时,一旦执行到return时,函数就执行完毕,并将结果返回。因此,函数内部通过条件判断和循环可以实现非常复杂的逻辑。

    如果没有return语句,函数执行完毕后也会返回结果,只是结果为 None。

    return None可以简写为return。

    任务

    请定义一个 square_of_sum 函数,它接受一个list,返回list中每个元素平方的和。

    答案

    def square_of_sum(L):
        return sum(x*x for x in L)
    print (square_of_sum([1, 2, 3, 4, 5]))
    print (square_of_sum([-5, 0, 5, 15, 25]))

    7-4 Python函数之返回多值

    Python函数之返回多值


    函数可以返回多个值吗?答案是肯定的。

    比如在游戏中经常需要从一个点移动到另一个点,给出坐标、位移和角度,就可以计算出新的坐标:

    # math包提供了sin()和 cos()函数,我们先用import引用它:
    import math
    def move(x, y, step, angle):
        nx = x + step * math.cos(angle)
        ny = y - step * math.sin(angle)
        return nx, ny

    这样我们就可以同时获得返回值:

    >>> x, y = move(100, 100, 60, math.pi / 6)
    >>> print x, y
    151.961524227 70.0

    但其实这只是一种假象,Python函数返回的仍然是单一值:

    >>> r = move(100, 100, 60, math.pi / 6)
    >>> print r
    (151.96152422706632, 70.0)

    用print打印返回结果,原来返回值是一个tuple!

    但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。

    任务

    一元二次方程的定义是:ax² + bx + c = 0

    请编写一个函数,返回一元二次方程的两个解。

    注意:Python的math包提供了sqrt()函数用于计算平方根。

    答案

    import math
    
    def quadratic_equation(a, b, c):
        deta = b**2 - 4*a*c
        if deta >= 0 :
            return (-b+math.sqrt(deta))/(2*a),(-b-math.sqrt(deta))/(2*a)
        else :
            return
    print (quadratic_equation(2, 3, 0))
    print (quadratic_equation(1, -6, 5))

    7-5 Python之递归函数

    Python之递归函数


    在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。

    举个例子,我们来计算阶乘 n! = 1 * 2 * 3 * … * n,用函数 fact(n)表示,可以看出:

    fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n

    所以,fact(n)可以表示为 n * fact(n-1),只有n=1时需要特殊处理。

    于是,fact(n)用递归的方式写出来就是:

    def fact(n):
        if n==1:
            return 1
        return n * fact(n - 1)

    上面就是一个递归函数。可以试试:

    >>> fact(1)
    1
    >>> fact(5)
    120
    >>> fact(100)
    93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L

    如果我们计算fact(5),可以根据函数定义看到计算过程如下:

    ===> fact(5)
    ===> 5 * fact(4)
    ===> 5 * (4 * fact(3))
    ===> 5 * (4 * (3 * fact(2)))
    ===> 5 * (4 * (3 * (2 * fact(1))))
    ===> 5 * (4 * (3 * (2 * 1)))
    ===> 5 * (4 * (3 * 2))
    ===> 5 * (4 * 6)
    ===> 5 * 24
    ===> 120

    递归函数的优点是定义简单,逻辑清晰。理论上,所有的递归函数都可以写成循环的方式,但循环的逻辑不如递归清晰。

    使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。可以试试计算 fact(10000)。

    任务

    汉诺塔 (http://baike.baidu.com/view/191666.htm) 的移动也可以看做是递归函数。

    我们对柱子编号为a, b, c,将所有圆盘从a移到c可以描述为:

    如果a只有一个圆盘,可以直接移动到c;

    如果a有N个圆盘,可以看成a有1个圆盘(底盘) + (N-1)个圆盘,首先需要把 (N-1) 个圆盘移动到 b,然后,将 a的最后一个圆盘移动到c,再将b的(N-1)个圆盘移动到c。

    请编写一个函数,给定输入 n, a, b, c,打印出移动的步骤:

    move(n, a, b, c)

    例如,输入 move(2, ‘A’, ‘B’, ‘C’),打印出:

    A --> B
    A --> C
    B --> C

    答案

    def move(n, a, b, c):
        if n == 1:
            print(a, "-->", c)  # 若剩下一个,则直接移动过去
            return
        else:
            move(n - 1, a, c, b)  # 递归,先把上面的N-1个放在B上
            print(a, "-->", c)  # 把 A上剩的那个最大的 放在C上
            move(n - 1, b, a, c)  # 把b上的 移动到C上
    
    
    move(4, 'A', 'B', 'C')
    

    #


    #


    7-6 Python之定义默认参数

    Python之定义默认参数


    定义函数的时候,还可以有默认参数。

    例如Python自带的 int() 函数,其实就有两个参数,我们既可以传一个参数,又可以传两个参数:

    >>> int('123')
    123
    >>> int('123', 8)
    83

    int()函数的第二个参数是转换进制,如果不传,默认是十进制 (base=10),如果传了,就用传入的参数。

    可见,函数的默认参数的作用是简化调用,你只需要把必须的参数传进去。但是在需要的时候,又可以传入额外的参数来覆盖默认参数值。

    我们来定义一个计算 x 的N次方的函数:

    def power(x, n):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s

    假设计算平方的次数最多,我们就可以把 n 的默认值设定为 2:

    def power(x, n=2):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s

    这样一来,计算平方就不需要传入两个参数了:

    >>> power(5)
    25

    由于函数的参数按从左到右的顺序匹配,所以默认参数只能定义在必需参数的后面:

    # OK:
    def fn1(a, b=1, c=2):
        pass
    # Error:
    def fn2(a=1, b):
        pass

    任务

    请定义一个 greet() 函数,它包含一个默认参数,如果没有传入,打印 ‘Hello, world.’,如果传入,打印 ‘Hello, xxx.’

    答案

    def greet(str='world'):
        print('hello,%s.' % str)
    
    
    greet()
    greet('Bart')
    

    7-7 Python之定义可变参数

    Python之定义可变参数


    如果想让一个函数能接受任意个参数,我们就可以定义一个可变参数:

    def fn(*args):
        print args

    可变参数的名字前面有个 * 号,我们可以传入0个、1个或多个参数给可变参数:

    >>> fn()
    ()
    >>> fn('a')
    ('a',)
    >>> fn('a', 'b')
    ('a', 'b')
    >>> fn('a', 'b', 'c')
    ('a', 'b', 'c')

    可变参数也不是很神秘,Python解释器会把传入的一组参数组装成一个tuple传递给可变参数,因此,在函数内部,直接把变量 args 看成一个 tuple 就好了。

    定义可变参数的目的也是为了简化调用。假设我们要计算任意个数的平均值,就可以定义一个可变参数:

    def average(*args):
        ...

    这样,在调用的时候,可以这样写:

    >>> average()
    0
    >>> average(1, 2)
    1.5
    >>> average(1, 2, 2, 3, 4)
    2.4

    任务

    请编写接受可变参数的 average() 函数。

    答案

    def average(*args):
        if len(args) > 0:
            return (sum(args)/len(args))
        else:
            return 0.0
    print (average())
    print (average(1, 2))
    print (average(1, 2, 2, 3, 4))

    展开全文
  • python中调用函数

    千次阅读 2015-08-25 19:27:26
    python中有内置的函数,我们可以直接调用来使用。调用函数需要写函数名和参数。 一、abs():求绝对值的函数,这个函数需要传一个整数或者浮点数...二、cmp():比较大小函数,需要传进两个参数 cmp(x,y) 当x>y,返回1;

    python中有内置的函数,我们可以直接调用来使用。调用函数需要写函数名参数

    一、abs():求绝对值的函数,这个函数需要传一个整数或者浮点数作为参数。


    如果参数个数传递错误,函数会报错:需要一个参数,但是给了两个


    如果参数类型传递错误,函数也会报类型错误:



    二、cmp():比较大小函数,需要传进两个参数

    cmp(x,y)

    当x>y,返回1;

    当x=y,返回0;

    当x<y,返回-1。


    三、类型转换函数

    int():需要传一个参数,将参数转换成整数

    str():需要传一个参数,将参数转换成字符串类型


    python还有很多内置的函数,有兴趣的朋友可以自己查看:

    http://docs.python.org/2/library/functions.html




    展开全文
  • Python的open函数

    千次阅读 2019-06-25 10:17:54
    Python 内置函数 Python 内置函数 python open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。 函数语法 open(name[, mode[, buffering]]) 参数说明 name : 一个包含了你要访问的...
  • python自定义排序函数

    万次阅读 2016-01-02 16:47:08
    python自定义排序函数,有两种方式 第一种自定义函数: # 自定义排序函数 def func(x,y): if x return -1 if x==y: return 0 else: return 1 a = [3,6,2,8,4] print u'正序排列:',sorted(a,func) print u'
  • Python——递归函数

    万次阅读 多人点赞 2018-08-16 19:30:46
    其实函数每次被调用时都会创建一个新命名空间,也就是当函数调用“自身”时,实际上运行的是两个不同的函数(也可以说一个函数具有两个不同的命名空间)。   【例】定义阶乘函数 递归实现: &gt;&gt;&...
  • 通过python比较两个数大小的方式,来看看函数怎么用。
  • Python shape函数获取数组大小

    千次阅读 2018-07-11 09:57:50
     数组的shape属性常用语获取一个数组的当前大小,与reshape函数相似,shape函数也可以更改数组大小,其中一个维度的大小可为-1,表明该处大小从数组的原size和剩余dimensions推算而来。示例: 最后一个示例没看懂...
  • python之SVD函数介绍

    万次阅读 2018-07-18 09:59:29
    1、python的mat函数  我们看到一开始随机生成的数组与使用mat函数之后的类型是发生了变化的,尽管他们显示的东西没有什么区别,但是实质上,他们的类型是不同的。调用mat()函数可以将数组转换为矩阵,然后可以对...
  • Python进阶-函数式编程

    千次阅读 2016-05-22 21:56:59
    花了一个多小时学习python函数式编程,终于算入门了,这接近一万字的教程,原作者分了十几课,我融合在一起方便查阅。函数式编程functional,是编程的一种范式特点有: 把计算视为函数而不是指令 纯函数式编程不...
  • python函数: 内置函数

    千次阅读 2015-03-30 19:25:11
    python内置函数 ...Python内置(built-in)函数随着python解释器的运行而创建。在Python的程序中,你可以随时调用这些函数,不需要定义。 Built-in Functions abs() dict() help() m...
  • python之open函数

    千次阅读 2018-12-24 19:42:31
    1 小序 1.0 功能 打开某个文件,创建一个file对象,调用相关方法进行读写. ...http://www.runoob.com/python/python-func-open.html [2] https://www.cnblogs.com/hackpig/p/8215786.html
  • Python 内置函数详解

    千次阅读 多人点赞 2019-11-13 17:21:35
    Python 的内置函数数量众多,功能强大,如果能够灵活运用,必将极大地提高编程效率。不过,在大家公认的所谓内置函数里面,有很多并不是真的函数,而是内置类,只是因为使用起来和真正的函数没有什么不同,所以也就...
  • Python中format函数用法说明

    千次阅读 2017-11-09 10:12:20
    Python中format函数用法说明
  • 关于python的open函数的误区。

    千次阅读 2016-01-01 20:05:54
    关于python内置文件函数open的问题。
  • 本文学习Python函数,包括:函数调用 定义函数 函数的参数 递归函数我们知道圆的面积计算公式为:S = π r*r当我们知道半径r的值时,就可以根据公式计算出面积。假设我们需要计算3个不同大小的圆的面积:r1 = 12.34 ...
  • Python中scatter函数参数详解

    万次阅读 多人点赞 2017-03-20 14:30:58
    最近开始学习Python编程,遇到scatter函数,感觉里面的参数不知道什么意思于是查资料,最后总结如下: 1、scatter函数原型 2、其中散点的形状参数marker如下: 3、其中颜色参数c如下: 4、基本的使用方法如下: ...
  • Python学习笔记3.2-python内置函数大全

    万次阅读 2016-11-22 22:28:09
    学习python不可避免的首先要了解python的内置函数,熟悉了这些以后可以给编程带来很大的方便。
  • python使用plot函数画图

    千次阅读 2020-05-21 19:25:45
    函数调用:plt.plot(*args, scalex=True, scaley=True, data=None, **kwargs) 各个参数的含义为: *args - 要绘制图形的函数横、纵坐标向量; scalex、scaley - 是否要进行横纵坐标轴的缩放,默认进行缩放,如果不...
  • python中max函数的用法解析

    万次阅读 2018-03-30 22:49:12
    python中 max函数可以输入一个参数,也可以输入两个参数。如果是一个参数,这个参数必须是可迭代的,max会for i in … 遍历一遍这个迭代器函数会返回其最大值,也可以给出key参数,这样函数会把第一个参数的每个值依次放...
  • Python 函数

    千次阅读 2013-03-01 01:38:58
    Python 第四部分 函数 目录 第15章 函数基础... 3 函数作用... 3 Def语句是实时执行的... 3 Python 中的多态... 4 第二个例子,寻找序列的交集... 4 什么时候python将会创建函数?. 5 检查传入函数的...
  • Turtle库是Python语言中一个很流行的绘制图像的函数库,今天通过实例代码给大家分享使用python的turtle函数绘制一个滑稽表情,一起看看吧 Turtle库是Python语言中一个很流行的绘制图像的函数库,想象一个小乌龟,在...
  • python函数——字符串字母大小判断

    千次阅读 2019-01-30 18:17:46
    python函数 系列目录:python函数——目录 字符串字母大小写转换: python函数——字符串字母大小写转换 Python提供了isupper(),islower(),istitle()方法用来判断字符串的大小写, 具体实例如下: ...
  • python函数

    千次阅读 2018-05-23 01:53:05
    1.函数的概念 概念:写了一段代码,实现某个小功能。然后把这些代码集中到一块,起一个名字。下次就可以根据这个名字再次...# 文件大小会变大 # 代码的冗余度比较大,重用性比较差 # 代码的可维护性比较差。 # ...
  • python 卷积函数What is a convolution? OK, that’s not such a simple question. Instead, I am will give you a very basic example and then I will show you how to do this in Python with actual functions. ...
  • 文章目录Python函数函数式编程1、函数概述1.1函数的基本概念1.2函数的功能1.3Python函数的分类2、函数的声明和调用2.1函 数对象的创建2.2函数的调用2.3函数的副作用3、参数的传递3.1形式参数和实际参数3.2形式...
  • python函数——目录

    千次阅读 多人点赞 2018-12-07 13:22:13
    python函数——目录 Python函数——Numpy size() python函数——字典get()方法 python函数——字典设置默认值 setdefault() python函数——字典设置默认值get() 与 setdefault()区别 ...
  • Python 内建函数 max/min的高级用法

    千次阅读 2018-09-01 15:54:32
    Python 中的 max/min函数是用来获取传入参数的最大值或最小值的,其运行机制都一样,所以这里主要描述 max 的运行机制以及使用方法。 最简单的用法,就是直接传入两个要对比的元素,可以返回其两个元素中的最大值。...
  • 使用python计算softmax函数

    千次阅读 2018-04-08 16:34:52
    b,如果以大小进行取值的话,那么a将永远被选用,而b则永远不会被选用。但是实际中,小概率事件有时也是会被选用的,只是可能性比较小罢了,softmax函数则解决了这个问题。 import numpy as np import math # ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 231,389
精华内容 92,555
关键字:

python比大小函数

python 订阅