python-函数与异常处理

---

函数

Python提供了三个类型的函数：普通函数、lambda函数（匿名函数）、和方法。在本章内容中我们介绍普通函数和lambda函数。

函数定义

def functionName(optional_parameters):
    suite

示例；

def greeting():
    print('welcome to python')

函数的名字必须是有效的标识符。函数可用括号进行调用，因此执行greeting( )函数应该这样做；

greeting()

输出：
welcome to python

接受参数的函数可以通过位置、名字或者两者的组合来给定各个参数的值。python没有提供可对各个浮点float进行操作的range()函数，因此这里我们自己创建一个这样的函数。

def frange(start,stop,inc):
    result = []
    while start < stop:
        result.append(start)
        start += inc
    return result

print(frange(0,5,0.5))

输出：
[0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]

回想range()函数是有是有三个参数的，而且参数可选择使用。接下来我们来创建一个完整版本的frange()。

def frange(arg0,arg1=None,arg2=None):
    """返回一个浮点数列表
    frange(start, stop, inc)  #start = arg0  stop = arg1  inc = arg2
    frange(start, stop)       #start = arg0  stop = arg1  inc = 1.0
    frange(stop)              #start = 0.0   stop = arg0  inc = 1.0
    """
    start = 0.0
    inc = 1.0
    if arg2 is not None:
        start = arg0
        stop = arg1
        inc = arg2
    elif arg1 is not None:
        start = arg0
        stop = arg1
    else:
        stop = arg0
    result = []
    while start < (stop - (inc / 2.0)):
        result.append(start)
        start += inc
    return result

print(frange(2,5,0.5))
print(frange(5,10))
print(frange(5))

输出：
[2, 2.5, 3.0, 3.5, 4.0, 4.5]
[5, 6.0, 7.0, 8.0, 9.0]
[0.0, 1.0, 2.0, 3.0, 4.0]

所有的python函数都会返回值。值的返回，要么可以是通过显式的使用return或者yield语句(后面会讲)，要么通过非显式的方式，此时python将会返回None。与C++ 和 Java不同，无需专门给定返回的类型：由于返回的是一个与任意类型绑定的对象引用，所以可以返回我们想要的任何类型。
python函数总是返回一个值，这个返回值可以是一个元组、一个列表或者是一个其他类型集合。

生成器函数

#生成返回列表
result = []
while start < (stop - (inc / 2.0)):
    result.append(start)
    start += inc
return result

像这样我们替换frang( )函数结尾的代码，就可以把函数转换成一个生成器。

#生成器
while start < (stop - (inc / 2.0)):
    yield start 
    start += inc

生成器没有返回语句，取而代之的是生成器有yield语句。如果一个生成器运行了所有的值，也就是说如果控制流程一直运行到函数的结尾，此时不再返回值，相反，python会抛出一个StopIteration异常

def grange(arg0,arg1=None,arg2=None):
    start = 0.0
    inc = 1.0
    if arg2 is not None:
        start = arg0
        stop = arg1
        inc = arg2
    elif arg1 is not None:
        start = arg0
        stop = arg1
    else:
        stop = arg0
    
    while start < (stop - (inc / 2.0)):
        yield start
        start += inc

print(grange(5))
输出：
<generator object frange at 0x7fe4200e4410>

现在我们调用frange(5)，将会得到一个生成器对象，而不是一个列表。当然通过调用list(frange(5))，可以强制让生成器返回一个列表。
不过生成器更为常见的用法是将其用在循环中；

for x in frange(5):
    print(x)

输出：
0.0
1.0
2.0
3.0
4.0

生成器是一个含有__next__()函数(3.0使用，2.0可以使用next())的对象，使用交互分析生成器的行为。
备注： 在python3.x版本中，python2.x的g.next()函数已经更名为g.__next__()，所以只需要将g.next()换成g.__next__()就可以了。如果你觉得g.__next__()太丑，使用next(g)也能达到相同效果。

>>> list(grange(1,5,0.5))
[1, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
>>> gen = grange(1,5,0.5)
>>> gen.__next__()
1
>>> next(gen)
1.5
>>> gen.__next__()
2.0
>>> gen.__next__()
2.5
>>> gen.__next__()
3.0
>>> gen.__next__()
3.5
>>> gen.__next__()
4.0
>>> gen.__next__()
4.5
>>> gen.__next__()
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    gen.__next__()
StopIteration

生成器完成后，并没有返回值，而是抛出一个StopIteration异常。在for循环的上下文中，会很好的处理这一异常，不会把它当做错误，而是将其作为迭代文成的说明加以处理。

匿名函数 lambda

除了 def 语句之外，python还提供了一种生成函数对象的表达式形式。与 def 一样，这个表达式创建了一个之后能够调用的函数，但是它返回该函数本身而不是将其赋值给一个变量名。这就是lambda函数，也叫匿名函数。

cube = lambda x: pow(x,3)

• lambda 是一个表达式，而不是语句；
• lambda 的主体是一个单独的表达式，而不是一个代码块。
  lambda 函数既不能包含控制结构（没有分支或者循环），也不能包含return语句：返回的值就仅仅是表达式计算所得到的的值。

程序入口

有时我们希望某文件被当做模板引进的时候，部分代码不要被执行。如果当前脚本含有单元测试，那么我们在其他地方调用此脚本的时候，测试部分就没有必要了。我们可以做以下的条件判断：

main()

if __name__ == '__main__':
    # statements

异常处理

有时候我们的程序会出现异常，但我们又不想这些代码影响到软件的正常运行，这时候我们就要使用Python中的try，来处理有可能出现的异常：

在python中，异常可以由内置的或者库的函数和方法抛出，也可以通过我们自己的代码抛出。抛出的异常可以是内置的任何异常类型，也可以是自定义的异常类型。

异常处理语法；

try:
    suite1
except exceptions:
    suite2
else:
    suite3

在这里，如果发生异常会执行suite1中的代码，控制流就会传递异常语句。如果异常语句正确，就会执行suite2；随后很快会讨论其他情况下发生的事情。如果没有异常出现，会再suite1中执行完毕后执行suite3。

异常语句不止一种语法格式；

except IndexError: pass
except ValueError, e: pass
except (IOError,OSError), e: pass
except: pass

Python也提供了很方便的finally，定义finally代码块后，不管try中的代码会不会引起异常，finally中的代码都会被执行：

try:
    print(a)
except:
    print("sth is wrong")
finally:
    print("'try except' is finished")

在处理文件的时候，我们经常会在finally中关闭文件，来保证程序的正常运行；

filehandle = open(filename)
try:
    for line in filehandle:
        process(line)
finally:
    filehandle.close()

filehandle = open("file.txt")
try:
    filehandle.write("welcome to python")
except:
    print("Something is wrong when writing to the file")
finally:
    filehandle.close()