精华内容
下载资源
问答
  • 一次函数常见题型归纳整理.doc
  • 一次函数知识点总结与常见题型-一次函数知识点整理汇编.docx
  • 一次函数知识点总结与常见题型.pdf
  • 一次函数知识点总结及常见题型.doc
  • 一次函数知识点总结与常见题型.doc
  • 一次函数知识点总结与常见题型汇编.doc
  • 一次函数知识点总结与常见题型34565.doc
  • 一次函数知识点总结和常见题型归类.doc
  • 北师大八年级上一次函数解析式常见题型总结.doc
  • 八年级数学下册第二十一章一次函数21.3用待定系数法确定一次函数表达式求一次函数解析式的常见题型素材新版冀教版
  • 第19章一次函数知识点总结和常见题型归类.doc
  • 第19章-一次函数知识点总结和常见题型归类.doc
  • 使用gets函数常见问题

    千次阅读 2019-09-28 13:17:40
    如若该行(包括最后一个换行符)的字符数超过bufsize-1,则fgets只返回一个不完整的行,但是,缓冲区总是以NULL字符结尾,对fgets的下一次调用会继续读该行。函数成功将返回buf,失败或读到文件结尾返回NULL。因此...
    C语言面试经常会考如下一道题,哪里有错误:

    #include <stdio.h> 
     
    int main() 
    {
        char string[100] = {'\0'}; 
         gets( string ); 
     
        printf("输入的字符串是:%s \n", string); 
     
        return 0; 
    这段C程序可能有问题,问题就在于函数gets()的使用。
    gets从标准输入设备读字符串函数, 可以无限读取,不会判断上限,以回车结束读取。所以如果输入的字符串超过100个,它也不会做检测,此时就会发生溢出。

    可以使用fgets函数来从文件中读取字符串。fgtes函数原型是
    char *fgets(char *buf, int bufsize, FILE *stream);
    一般的教材都会对这个函数的用法作出解释,这里就不在详述了,以下文字摘用百度百科的解释:
    百度百科对fgets函数的解释
    从文件结构体指针stream中读取数据,每次读取一行。读取的数据保存在buf指向的字符数组中,每次最多读取bufsize-1个字符(第bufsize个字符赋'\0'),如果文件中的该行,不足bufsize个字符,则读完该行就结束。如若该行(包括最后一个换行符)的字符数超过bufsize-1,则fgets只返回一个不完整的行,但是,缓冲区总是以NULL字符结尾,对fgets的下一次调用会继续读该行。函数成功将返回buf,失败或读到文件结尾返回NULL。因此我们不能直接通过fgets的返回值来判断函数是否是出错而终止的,应该借助feof函数或者ferror函数来判断。

    转载于:https://www.cnblogs.com/itblog/p/7236572.html

    展开全文
  • 如果你经常参加笔试或者也是个过来人,相信你也跟我一样,发现字符串的处理是前端招聘过程中最常见题型。这些题有个特点,站在考官的角度去考虑,它考的不是你会不会,而是你能不能在不借用XX手册或者XX...
  • 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
    

    其余参考原文
    菜鸟教程

    展开全文
  • 常见损失函数

    千次阅读 2017-05-08 09:21:36
    损失函数(loss function)是用来估量你模型的预测值f(x)与真实值Y的不一致程度,它是个非负实值函数,通常使用L(Y, f(x))来表示,损失函数越小,模型的鲁棒性就越好。损失函数是经验风险函数的核心部分,也是结构...

    转自:http://blog.csdn.net/shenxiaoming77/article/details/51614601

    损失函数(loss function)是用来估量你模型的预测值f(x)与真实值Y的不一致程度,它是一个非负实值函数,通常使用L(Y, f(x))来表示,损失函数越小,模型的鲁棒性就越好。损失函数是经验风险函数的核心部分,也是结构风险函数重要组成部分。模型的结构风险函数包括了经验风险项和正则项,通常可以表示成如下式子:
    $$\theta^* = \arg \min_\theta \frac{1}{N}{}\sum_{i=1}^{N} L(y_i, f(x_i; \theta) + \lambda\  \Phi(\theta)$$

    其中,前面的均值函数表示的是经验风险函数,L代表的是损失函数,后面的 Φ Φ是正则化项(regularizer)或者叫惩罚项(penalty term),它可以是L1,也可以是L2,或者其他的正则函数。整个式子表示的意思是找到使目标函数最小时的 θ θ。下面主要列出几种常见的损失函数。

    一、log对数损失函数(逻辑回归)

    有些人可能觉得逻辑回归的损失函数就是平方损失,其实并不是。平方损失函数可以通过线性回归在假设样本是高斯分布的条件下推导得到,而逻辑回归得到的并不是平方损失。在逻辑回归的推导中,它假设样本服从伯努利分布(0-1分布),然后求得满足该分布的似然函数,接着取对数求极值等等。而逻辑回归并没有求似然函数的极值,而是把极大化当做是一种思想,进而推导出它的经验风险函数为:最小化负的似然函数(即max F(y, f(x)) —-> min -F(y, f(x)))。从损失函数的视角来看,它就成了log损失函数了。

    log损失函数的标准形式

    L(Y,P(Y|X))=logP(Y|X) L(Y,P(Y|X))=−log⁡P(Y|X)

    刚刚说到,取对数是为了方便计算极大似然估计,因为在MLE中,直接求导比较困难,所以通常都是先取对数再求导找极值点。损失函数L(Y, P(Y|X))表达的是样本X在分类Y的情况下,使概率P(Y|X)达到最大值(换言之, 就是利用已知的样本分布,找到最有可能(即最大概率)导致这种分布的参数值;或者说什么样的参数才能使我们观测到目前这组数据的概率最大 )。因为log函数是单调递增的,所以logP(Y|X)也会达到最大值,因此在前面加上负号之后,最大化P(Y|X)就等价于最小化L了。
    逻辑回归的P(Y=y|x)表达式如下:
    P(Y=y|x)=11+exp(yf(x)) P(Y=y|x)=11+exp(−yf(x))

    将它带入到上式,通过推导可以得到logistic的损失函数表达式,如下:
    L(y,P(Y=y|x))=log(1+exp(yf(x))) L(y,P(Y=y|x))=log⁡(1+exp(−yf(x)))

    逻辑回归最后得到的目标式子如下:

    $$J(\theta) = - \frac{1}{m}\left [ \sum_{i=1}^m y^{(i)} \log h_{\theta}(x^{(i)}) + (1-y^{(i)}) \log(1-h_{\theta}(x^{(i)}))  \right ]$$

    如果是二分类的话,则m值等于2,如果是多分类,m就是相应的类别总个数。这里需要解释一下:之所以有人认为逻辑回归是平方损失,是因为在使用梯度下降来求最优解的时候,它的迭代式子与平方损失求导后的式子非常相似,从而给人一种直观上的错觉

    这里有个PDF可以参考一下:Lecture 6: logistic regression.pdf.

    二、平方损失函数(最小二乘法, Ordinary Least Squares )

    最小二乘法是线性回归的一种,OLS将问题转化成了一个凸优化问题。在线性回归中,它假设样本和噪声都服从高斯分布(为什么假设成高斯分布呢?其实这里隐藏了一个小知识点,就是中心极限定理,可以参考【central limit theorem】),最后通过极大似然估计(MLE)可以推导出最小二乘式子。最小二乘的基本原则是:最优拟合直线应该是使各点到回归直线的距离和最小的直线,即平方和最小。换言之,OLS是基于距离的,而这个距离就是我们用的最多的欧几里得距离。为什么它会选择使用欧式距离作为误差度量呢(即Mean squared error, MSE),主要有以下几个原因:

    • 简单,计算方便;
    • 欧氏距离是一种很好的相似性度量标准;
    • 在不同的表示域变换后特征性质不变。

    平方损失(Square loss)的标准形式如下:

    L(Y,f(X))=(Yf(X))2 L(Y,f(X))=(Y−f(X))2

    当样本个数为n时,此时的损失函数变为:
    $$L(Y, f(X)) = \sum _{i=1}^{n}(Y - f(X))^2$$
    Y-f(X) 表示的是残差,整个式子表示的是 残差的平方和 ,而我们的目的就是最小化这个目标函数值(注:该式子未加入正则项),也就是最小化残差的平方和(residual sum of squares,RSS)。

    而在实际应用中,通常会使用均方差(MSE)作为一项衡量指标,公式如下:

    MSE=1ni=1n(Yi~Yi)2 MSE=1n∑i=1n(Yi~−Yi)2

    上面提到了线性回归,这里额外补充一句,我们通常说的线性有两种情况,一种是因变量y是自变量x的线性函数,一种是因变量y是参数 α α 的线性函数。在机器学习中,通常指的都是后一种情况。

    三、指数损失函数(Adaboost)

    学过Adaboost算法的人都知道,它是前向分步加法算法的特例,是一个加和模型,损失函数就是指数函数。在Adaboost中,经过m此迭代之后,可以得到 fm(x) fm(x):

    $$f_m (x) = f_{m-1}(x) + \alpha_m G_m(x)$$

    Adaboost每次迭代时的目的是为了找到最小化下列式子时的参数 α α 和G:

    $$\arg \min_{\alpha, G} = \sum_{i=1}^{N} exp[-y_{i} (f_{m-1}(x_i) + \alpha G(x_{i}))]$$

    而指数损失函数(exp-loss)的标准形式如下

    $$L(y, f(x)) = \exp[-yf(x)]$$

    可以看出,Adaboost的目标式子就是指数损失,在给定n个样本的情况下,Adaboost的损失函数为:

    L(y, f(x)) = \frac{1}{n}\sum_{i=1}^{n}\exp[-y_if(x_i)]

    关于Adaboost的推导,可以参考Wikipedia:AdaBoost或者《统计学习方法》P145.

    四、Hinge损失函数(SVM)

    机器学习算法中,hinge损失函数和SVM是息息相关的。在线性支持向量机中,最优化问题可以等价于下列式子:
    $$\min_{w,b}  \ \sum_{i}^{N} [1 - y_i(w\cdot x_i + b)]_{+} + \lambda||w||^2 $$
    下面来对式子做个变形,令:
    $$[1 - y_i(w\cdot x_i + b)]_{+} = \xi_{i}$$
    于是,原式就变成了:
    $$\min_{w,b}  \ \sum_{i}^{N} \xi_i + \lambda||w||^2 $$
    如若取 λ=12C λ=12C,式子就可以表示成:
    $$\min_{w,b}  \frac{1}{C}\left ( \frac{1}{2}\ ||w||^2 $$ + C \sum_{i}^{N} \xi_i\right )$$
    可以看出,该式子与下式非常相似:
    $$\frac{1}{m} \sum_{i=1}^{m} l(w \cdot  x_i + b, y_i) + ||w||^2$$

    前半部分中的 l l就是hinge损失函数,而后面相当于L2正则项。

    Hinge 损失函数的标准形式

    L(y)=max(0,1yy~),y=±1 L(y)=max(0,1−yy~),y=±1

    可以看出,当|y|>=1时,L(y)=0。

    更多内容,参考Hinge-loss

    补充一下:在libsvm中一共有4中核函数可以选择,对应的是-t参数分别是:

    • 0-线性核;
    • 1-多项式核;
    • 2-RBF核;
    • 3-sigmoid核。

    五、其它损失函数

    除了以上这几种损失函数,常用的还有:

    0-1损失函数
    L(Y, f(X)) = \left\{\begin{matrix}1 ,& Y \neq f(X)\\ 0 ,& y = f(X)    \end{matrix}\right.
    绝对值损失函数
    $$L(Y, f(X)) = |Y-f(X)|$$
    下面来看看几种损失函数的可视化图像,对着图看看横坐标,看看纵坐标,再看看每条线都表示什么损失函数,多看几次好好消化消化。

    OK,暂时先写到这里,休息下。最后,需要记住的是:参数越多,模型越复杂,而越复杂的模型越容易过拟合。过拟合就是说模型在训练数据上的效果远远好于在测试集上的性能。此时可以考虑正则化,通过设置正则项前面的hyper parameter,来权衡损失函数和正则项,减小参数规模,达到模型简化的目的,从而使模型具有更好的泛化能力。

    展开全文
  • 概率密度函数是概率论中的核心概念之,用于描述连续型随机变量所服从的概率分布。 从随机事件说起 回忆我们在学习概率论时的经历,随机事件是第个核心的概念,它定义为可能发生也可能不发生的事件,因此是否发生...

    1. 概率函数

    概率函数,就是用函数的形式来表达概率。
    p i = P ( X = a i ) ( i = 1 , 2 , 3 , 4 , 5 , 6 ) p_i=P(X=a_i)(i=1,2,3,4,5,6) pi=P(X=ai)(i=1,2,3,4,5,6)
    在这个函数里,自变量(X)是随机变量的取值,因变量( p i p_i pi)是取值的概率。这就叫啥,这叫用数学语言来表示自然现象!它就代表了每个取值的概率,所以顺理成章的它就叫做了X的概率函数。
    从公式上来看,概率函数一次只能表示一个取值的概率。比如P(X=1)=1/6,这代表用概率函数的形式来表示,当随机变量取值为1的概率为1/6,一次只能代表一个随机变量的取值。

    2. 概率分布

    概率分布,就是概率的分布,这个概率分布还是讲概率的。我认为在理解这个概念时,关键不在于“概率”两个字,而在于“分布”这两个字。为了理解“分布”这个词,我们来看一张图。
    在这里插入图片描述
    在很多教材中,这样的列表都被叫做离散型随机变量的“概率分布”。其实严格来说,它应该叫“离散型随机变量的值分布和值的概率分布列表”,这个名字虽然比“概率分布”长了点,但是对于我们这些笨学生来说,肯定好理解了很多。因为这个列表,上面是值,下面是这个取值相应取到的概率,而且这个列表把所有可能出现的情况全部都列出来了!

    举个例子吧,一颗6面的骰子,有1,2,3,4,5,6这6个取值,每个取值取到的概率都为1/6。那么你说这个列表是不是这个骰子取值的”概率分布“?
    在这里插入图片描述
    长得挺像的,上面是取值,下面是概率,这应该就是骰子取值的“概率分布”了吧!大错特错!少了一个最重要的条件!对于一颗骰子的取值来说,它列出的不是全部的取值,把6漏掉了!

    这么一说你就应该明白概率分布是个什么鬼了吧。

    3. 分布函数

    说完概率分布,就该说说分布函数了。这个分布函数又是个简化版的东西!我真的很讨厌我们的教材中老是故弄玄虚,卖弄概念!你就老老实实的写成”概率分布函数“,让我们这些笨学生好理解一些不行吗?

    看看下图中的分布律!这又是一个不统一叫法的丑恶典型!这里的分布律明明就是我们刚刚讲的“概率函数”,完全就是一个东西嘛!但是我知道很多教材就是叫分布律的。
    在这里插入图片描述
    我们来看看图上的公式,其中的F(x)就代表概率分布函数啦。这个符号的右边是一个长的很像概率函数的公式,但是其中的等号变成了大于等于号的公式。你再往右看看,这是一个一个的概率函数的累加!发现概率分布函数的秘密了吗?它其实根本不是个新事物,它就是概率函数取值的累加结果!所以它又叫累积概率函数!其实,我觉得叫它累积概率函数还更好理解!!

    概率函数和概率分布函数就像是一个硬币的两面,它们都只是描述概率的不同手段!

    4. 概率密度函数

    概率密度函数是概率论中的核心概念之一,用于描述连续型随机变量所服从的概率分布。

    4.1 从随机事件说起

    研究一个随机变量,不只是要看它能取哪些值,更重要的是它取各种值的概率如何!
    回忆我们在学习概率论时的经历,随机事件是第一个核心的概念,它定义为可能发生也可能不发生的事件,因此是否发生具有随机性。例如,抛一枚硬币,可能正面朝上,也可能反面朝上,正面朝上或者反面朝上都是随机事件。掷骰子,1到6这6种点数都可能朝上,每种点数朝上,都是随机事件。
    在这里插入图片描述
    在这里插入图片描述

    4.2 整数集与实数集

    高中时我们学过集合的概念,并且知道整数集是z,实数集是R。对于有限集,可以统计集合中元素的数量即集合的基数(cardinal number,也称为集合的势cardinality)。对于无限集,元素的个数显然是无穷大,但是,都是无穷大,能不能分个三六九等呢?

    回忆微积分中的极限,对于下面的极限:
    在这里插入图片描述

    虽然当x趋向于正无穷的时候,x和exp(x)都是无穷大,但它们是有级别的,在exp(x)面前,x是小巫见老巫。

    同样的,对于整数集和实数集,也是有级别大小的。任意两个整数之间,如1与2之间,都密密麻麻的分布着无穷多个实数,而且,只要两个实数不相等,不管它们之间有多靠近,如0.0000001和0.0000002,在它们之间还有无穷多个实数。在数轴上,整数是离散的,而实数则是连续的,密密麻麻的布满整个数轴。因此,实数集的元素个数显然比整数要高一个级别。

    4.3 随机变量

    变量是我们再熟悉不过的概念,它是指一个变化的量,可以取各种不同的值。随机变量可以看做是关联了概率值的变量,即变量取每个值有一定的概率。例如,你买彩票,最后的中奖金额x就是一个随机变量,它的取值有3种情况,以0.9的概率中0元,0.09的概率中100元,0.01的概率中1000元。变量的取值来自一个集合,可以是有限集,也可以是无限集。对于无限集,可以是离散的,也可以是连续的,前者对应于整数集,后者对应于实数集。

    4.3.1 离散型随机变量

    随机变量是取值有多种可能并且取每个值都有一个概率的变量。它分为离散型和连续型两种,离散型随机变量的取值为有限个或者无限可列个(整数集是典型的无限可列),连续型随机变量的取值为无限不可列个(实数集是典型的无限不可列)。
    在这里插入图片描述

    4.3.2 连续型随机变量

    把分布表推广到无限情况,就可以得到连续型随机变量的概率密度函数。此时,随机变量取每个具体的值的概率为0,但在落在每一点处的概率是有相对大小的,描述这个概念的,就是概率密度函数。你可以把这个想象成一个实心物体,在每一点处质量为0,但是有密度,即有相对质量大小。
    在这里插入图片描述
    在这里插入图片描述
    在概率论和统计学中,拉普拉斯是一种连续概率分布。由于它可以看做是俩个不同位置的指数分布背靠背拼在一起,所以它也叫做双指数分布。如果随机变量的概率密度函数分布为:
    在这里插入图片描述
    那么他就是拉普拉斯分布。u为位置参数,b>0是尺度参数。与正态分布相比,正态分布是用相对于u平均值的差的平方来表示,而拉普拉斯概率密度用相对于差的绝对值来表示。因此,拉普拉斯的尾部比正态分布更加平坦。
    在这里插入图片描述

    在这里插入图片描述
    概率密度函数用数学公式表示就是一个定积分的函数,定积分在数学中是用来求面积的,而在这里,你就把概率表示为面积即可!
    在这里插入图片描述
    左边是F(x)连续型随机变量分布函数画出的图形,右边是f(x)连续型随机变量的概率密度函数画出的图像,它们之间的关系就是,概率密度函数是分布函数的导函数。

    两张图一对比,你就会发现,如果用右图中的面积来表示概率,利用图形就能很清楚的看出,哪些取值的概率更大!这样看起来是不是特别直观,特别爽!!所以,我们在表示连续型随机变量的概率时,用f(x)概率密度函数来表示,是非常好的!

    但是,可能读者会有这样的问题:
    Q:概率密度函数在某一点的值有什么意义?
    A:比较容易理解的意义,某点的 概率密度函数 即为 概率在该点的变化率(或导数)。很容易误以为 该点概率密度值 为 概率值.
    比如: 距离(概率)和速度(概率密度)的关系.某一点的速度, 不能以为是某一点的距离,没意义,因为距离是从XX到XX的概念,所以, 概率也需要有个区间.
    这个区间可以是x的邻域(可以无限趋近于0)。对x邻域内的f(x)进行积分,可以求得这个邻域的面积,就代表了这个邻域所代表这个事件发生的概率。

    4.4 期望E(X)与方差Var(X)

    随机变量(Random Variable)X是一个映射,把随机试验的结果与实数建立起了一一对应的关系。而期望与方差是随机变量的两个重要的数字特这。

    期望(Expectation, or expected value)是度量一个随机变量取值的集中位置或平均水平的最基本的数字特征;

    方差(Variance)是表示随机变量取值的分散性的一个数字特征。 方差越大,说明随机变量的取值分布越不均匀,变化性越强;方差越小,说明随机变量的取值越趋近于均值,即期望值。
    在这里插入图片描述

    4.4.1 期望和方差的运算性质

    4.4.1.1 期望运算性质

    在这里插入图片描述

    4.4.1.2 方差的运算性质

    在这里插入图片描述
    在这里插入图片描述

    4.4.1.3 期望与方差的联系

    在这里插入图片描述

    4.4.2 协方差

    在这里插入图片描述

    4.4.2.1 协方差的运算性质

    在这里插入图片描述

    4.4.3 相关系数

    4.4.3.1 定义

    相关系数通过方差和协方差定义。两个随机变量的相关系数被定义为:
    在这里插入图片描述

    4.4.3.2 性质

    1、有界性
    相关系数的取值范围为-1到1,其可以看成是无量纲的协方差。

    2、统计意义
    值越接近1,说明两个变量正相关性(线性)越强,越接近-1,说明负相关性越强,当为0时表示两个变量没有相关性。

    在这里插入图片描述

    5. 常见概率分布

    5.1 均匀分布(Uniform Distribution)

    在这里插入图片描述
    在这里插入图片描述

    5.2 伯努利分布(Bernoulli Distribution)

    在这里插入图片描述

    在这里插入图片描述

    5.3 二项分布(Binomial Distribution)

    二项分布(Binomial distribution)是n重伯努利试验成功次数的离散概率分布。
    在这里插入图片描述

    从定义可以看出,伯努利分布是二项分布在n=1时的特例

    在这里插入图片描述

    5.4 负二项分布(Negative Binomial Distribution)

    在这里插入图片描述
    在这里插入图片描述

    5.5 几何分布(Geometric Distribution)

    假定我们有一系列伯努利试验,其中每一个的成功概率为 p p p,失败概率为 q = 1 − p q=1-p q=1p。在获得一次成功前要进行多次试验?
    注意,这里的随机变量的概率分布就是一种几何分布。具体如下:

    在这里插入图片描述
    几何分布的概率分布图如下,见之会有更形象地认知。
    在这里插入图片描述
    为什么单独把几何分布和二项分布单独列出,一方面其代表的概率试验的普适性,另一方面其期望和方差都是有特殊技巧。
    在这里插入图片描述
    其实有意思的是,这里面的求解过程;但是本文不具体涉及了。因为像几何分布和二项分布这种可能要多写几章,当然是否连续写就不知道了。本着实用主义来。
    一般简单地肯定在前面讲,复杂一些得也更有意思一些的肯定是在后面,比如二项分布明显就在几何分布后面了。

    不同于几何分布描述的运行到第几次才成功,二项分布描述是的N次试验里有多少次成功。具体如下:
    在这里插入图片描述

    在这里插入图片描述

    5.6 超几何分布(Hypergeometric Distibution)

    在这里插入图片描述

    5.7 正态/高斯分布 (Normal / Gaussian Distribution)

    正态分布是很多应用中的合理选择。如果某个随机变量取值范围是实数,且对它的概率分布一无所知,通常会假设它服从正态分布。有两个原因支持这一选择:

    • 建模的任务的真实分布通常都确实接近正态分布。中心极限定理表明,多个独立随机变量的和近似正态分布。
    • 在具有相同方差的所有可能的概率分布中,正态分布的熵最大(即不确定性最大)。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5.7.1 一维正态分布

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5.7.2 多维正态分布

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5.8 拉普拉斯分布

    在这里插入图片描述

    5.9 泊松分布(Poisson Distribution)

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    5.10 指数分布

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5.11 伽马分布

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    5.12 贝塔分布

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5.13 狄拉克分布

    在这里插入图片描述

    5.14 多项式分布与狄里克雷分布

    多项式分布(Multinomial Distribution)是二项式分布的推广。二项式做n次伯努利实验,规定了每次试验的结果只有两个,如果现在还是做n次试验,只不过每次试验的结果可以有多m个,且m个结果发生的概率互斥且和为1,则发生其中一个结果X次的概率就是多项式分布。

    扔骰子是典型的多项式分布。扔骰子,不同于扔硬币,骰子有6个面对应6个不同的点数,这样单次每个点数朝上的概率都是1/6(对应p1~p6,它们的值不一定都是1/6,只要和为1且互斥即可,比如一个形状不规则的骰子),重复扔n次,如果问有k次都是点数6朝上的概率就是
    在这里插入图片描述
    在这里插入图片描述

    5.15 混合概率分布

    在这里插入图片描述

    5.16 总结

    在这里插入图片描述

    在这里插入图片描述

    https://www.jianshu.com/p/b570b1ba92bb
    https://zhuanlan.zhihu.com/p/48140593
    https://www.bookstack.cn/read/huaxiaozhuan-ai/spilt.4.6f06ed449f5ed789.md
    https://zhuanlan.zhihu.com/p/94181395
    https://zhuanlan.zhihu.com/p/64859161
    https://blog.csdn.net/touristman5/article/details/56281887
    https://zhuanlan.zhihu.com/p/32932782

    展开全文
  • 回归模型常见的损失函数

    万次阅读 2019-05-21 01:17:44
    机器学习中的所有算法都依赖于最小化或最大化函数,我们将其称为“目标函数...没有种损失函数适用于所有类型的数据。它取决于许多因素,包括异常值的存在,机器学习算法的选择,梯度下降的时间效率,易于找到衍生...
  • 规划问题和MATLAB函数quadprog的使用

    千次阅读 多人点赞 2019-06-02 10:46:53
    对于凸二规划,目标函数q(x)是个凸函数。如果有至少个向量x满足约束而且q(x)在可行域有下界,二规划问题就有个全局最小值x。 如果G是正定矩阵,则称此规划为严格凸二规划,此时全局...
  • 样条函数插值(Cubic spline function interpolation)

    万次阅读 多人点赞 2019-05-23 11:36:01
    样条函数插值(Cubic spline function interpolation) 预备知识: 什么是插值? 已知离散的数据,但不知函数表达式,插值和拟合都是为了寻找函数表达式。区别在于,插值得到的函数能够穿过已知的点(在已知的...
  • 常见机器学习损失函数(Loss Function)  损失函数(loss function)是用来估量模型的预测值f(x)与真实值Y的不一致程度,它是个非负实值函数,通常使用L(Y, f(x))来表示,损失函数越小,模型的鲁棒性就越好...
  • 一些常见数列的生成函数推导

    千次阅读 2016-11-14 23:07:07
    曾经有人问过我:“斐波那契数列的生成函数长啥样?” 。。。所以这东西我还是写一发吧 它有什么用?它没啥用。。。1.齐线性递推数列定义:给定常数k,a1,a2,...,ak,h0,h1,...,hk−1k,a_1,a_2,...,a_k,h_0,h_1,.....
  • 在多层神经网络中,上层节点的输出和下层节点的输入之间具有函数关系,这个函数称为激活函数。 问:激活函数有什么用? 如果没有激励函数,在这种情况下你每层节点的输入都是上层输出的线性函数,无论你神经...
  • 四、scanf函数使用常见问题 、scanf函数介绍 scanf()是C语言中的个输入函数。与printf函数一样,都被声明在头文件stdio.h里,因此在使用scanf函数时要加上#include <stdio.h>。它是格式输入函数,即按...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 444,705
精华内容 177,882
关键字:

一次函数常见题型