Python 常用内置函数如下：

Python 解释器内置了很多函数和类型，您可以在任何时候使用它们。以下按字母表顺序列出它们。

返回数字的绝对值。

print( abs(-45) )                  # 返回 45

print("abs(0.2):",abs(0.2))        # 返回 abs(0.2): 0.2

用于判断给定的参数中的所有元素是否都为
TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。

print( all( [0.1,1,-1] )  )       
# 返回 True

print( all( (None,1) )  )         
# 返回 False（其中一个元素为None）

print( all( [0,1,-1] )  )         
# 返回 False（其中一个元素为0）

print( all( [" ","a",""] )  )      # 返回 False(第三个元素为空)

用于判断给定的参数是否全部为False，是则返回False，如果有一个为True，则返回True。 元素除了是 0、空、False外都算 TRUE。

# 参数全部不为 0、空、FALSE

print(any("-45"))                 #  True

print(any(["-45"]))               #  True

print( any( ("0","ab","") )
)     #  True（注意：第一个参数0加了双引号，表示为一个字符串）

# 参数全部为 0、空、False

print( any( (0,"") ) )            # 
False

print( any( (0,"",False) ) )      #  False

返回一个整数int或者长整数long int的二进制表示。

print( bin(10) )        # 
0b1010

print( bin(133) )       # 
0b10000101

用于将给定参数转换为布尔类型，如果参数不为空或不为0，返回True；参数为0或没有参数，返回False。

print( bool(10) )                 #  True

print( bool([0]) )                #  True

print( bool(["123","s",0]) )      # 
True

print( bool(0) )                  # 
False

print( bool() )                   # 
False

返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256（即0-255）。即bytearray()是可修改的二进制字节格式。

1 b = bytearray("abcd",encoding="utf-8")

2 print(b[0])            #  返回数字97，即把“abcd”的“a"对应的ascii码打印出来了

3 b[0] = 99              #  把字符串第一个字节修改为99（即对应字母为“c”）

4 print(b)               #  返回：bytearray(b'cbcd')---第一个字节a已被修改为c

用于检查一个对象是否可调用的。对于函数、方法、lambda函式、类以及实现了 __call__ 方法的类实例, 它都返回 True。（可以加括号的都可以调用）

1 def sayhi():pass                 #  先定义一个函数sayhi()

2 print( callable( sayhi ) )       # 
True

1 a = 1

2 print( callable( a ) )           # 
False

用一个范围在range(256)内（即0～255）的整数作参数，返回一个对应的ASCII数值。

# 把数字98在ascii码中对应的字符打印出来

print( chr(98) )                   #  返回：b

用来将元组/列表转换为字典格式。

print(dict(a='a', b='b', t='t'))

#  返回：{'b': 'b', 'a': 'a', 't': 't'}

print(dict( [ ('one',1),('two',2),('three',3) ] 
) )   # 可迭代对象方式来构造字典

#  返回：{'two': 2, 'one': 1, 'three': 3}

print(dict(zip(["1","2","3"],["a","b","c"])))     # 映射函数方式来构造字典

#  返回：{'2': 'b', '3': 'c', '1': 'a'}

不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

print( dir() )           #  获得当前模块的属性列表

#  返回：['__builtins__', '__cached__', '__doc__',
'__file__', '__loader__', '__name__', '__package__', '__spec__']

print( dir([]) )         #  查看列表的方法

#  返回：['__add__', '__class__', '__contains__',
'__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__',
'__ge__',

'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__',
'__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',

'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__reversed__', '__rmul__', '__setattr__', '__setitem__',

'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy',
'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',

'sort']

把除数和余数运算结果结合起来，返回一个包含商和余数的元组（商x，余数y）。

print( divmod(5,2) )    #  返回：(2, 1)

print( divmod(5,1) )    #  返回：(5, 0)

print( divmod(5,3) )    #  返回：(1, 2)

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。Python 2.3. 以上版本可用，2.6 添加 start 参数。

1 seasons = ['Spring', 'Summer', 'Fall', 'Winter']

2 print(list(enumerate(seasons)))                 

#  返回：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'),
(3, 'Winter')]

1 print(list(enumerate(seasons, start=1)) )         # 下标从 1 开始

#  返回：[(1, 'Spring'), (2, 'Summer'), (3,
'Fall'), (4, 'Winter')]

用来执行一个字符串表达式，并返回表达式的值。

print(eval('3 * 2'))         
# 6

1 x = 7

2 print(eval('3 + x'))       
# 10

执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。

exec("print('Hello World')")       
# 执行简单的字符串

Hello World

exec("for i in range(5): print('iter time is %d'%i)")     
# 执行复杂的for循环

iter time is 0

iter time is 1

iter time is 2

iter time is 3

iter time is 4

用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，可用list()来转换为列表。

注意： filter()接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或 False，最后将返回
True 的元素放到新列表中。

res
= filter(lambda n:n>5,range(10))   # 过滤掉0-9中不符合n>5的数据

for i in res:                          # 循环打印符合n>5的数据

print(i)

# 5

# 6

# 7

# 8

# 9

是一种格式化字符串的函数 ，基本语法是通过
{} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。

# 位置映射

print( "{}{}".format('a','1') )

# a1

print('name:{n},url:{u}'.format(n='alex',u='www.xxxxx.com'))

name:alex,url:www.xxxxx.com

# 元素访问

print( "{0[0]},{0[1]}".format(('baidu','com')) )                # 按顺序

baidu,com

print( "{0[2]},{0[0]},{0[1]}".format(('baidu','com','www')) )  
# 不按顺序

www,baidu,com

用于将整数和字符串转换成浮点数。

print(float(1))

1.0

print(float(0.1))

0.1

print(float('123'))

123.0

返回一个冻结的集合（一个无序的不重复元素序列），冻结后集合不能再添加或删除任何元素。

1 a = frozenset(range(10))             # 先创建一个冻结集合

2 print(a)

3 # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

4

5 del a[0]                             # 试图删除冻结集合a中的元素，报错

6 # TypeError: 'frozenset' object doesn't support item
deletion

1 b = frozenset("happy")               # 将字符串转换成一个集合

2 print(b)

3 # frozenset({'a', 'h', 'p', 'y'})    # 无序不重复

1 c = frozenset()                      # 创建一个空集合

2 print(c)

3 # frozenset()                        # 如果不提供任何参数，默认会生成空集合

会以字典格式返回当前位置的全部全局变量。

print(globals())     # globals 函数返回一个全局变量的字典，包括所有导入的变量。

#  {'__file__':
'C:/Users/Administrator/PycharmProjects/test/day4/内置函数-globals().py', '__spec__': None, '__doc__': None,
'__package__': None,

 'a': 'append', '__cached__': None,
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000666B00>,

'__builtins__': , '__name__': '__main__'}

用于判断对象是否包含对应的属性。如果对象有该属性返回 True，否则返回 False。

1 class t:

2    
a = 1

3    
b = 2

4    
c = 3

5

6 p = t()

7 print(hasattr(p,'a'))   
# True

8 print(hasattr(p,'b'))   
# True

9 print(hasattr(p,'x'))   
# False

用于获取一个对象（数字或者字符串等）的哈希值。不能直接应用于 list、set、dictionary。

注意：在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。

print(hash(1))                  # 1

print(hash(20000))              # 20000

print(hash('123'))              # -6436280630278763230

print(hash('ab12'))            

5468785079765213470

print(hash('ab12'))            

5468785079765213470

用于查看函数或模块用途的详细说明。

help('sys')            
# 查看 sys 模块的帮助

help('str')            
# 查看 str 数据类型的帮助

a =
[1,2,3]

help(a)                 # 查看列表 list 帮助信息

help(a.append)          # 显示list的append方法的帮助

用于将一个整数转换为十六进制数。返回一个字符串，以0x开头。

print(hex(1))        # 0x1

print(hex(-256))     # -0x100

print(type(hex(-256)))    #

用于获取对象的内存地址。

a = "123"                             # 字符串

print(id(a))                          # 13870392

b =
[1,2,3]                           # 列表

print(id(b))                          # 7184328

c =
{'num1':1,'num2':2,'num3':3}       # 字典

print(id(c))                           # 6923656

接受一个标准输入数据，返回为 string
类型。这个函数是最最常用的了。在Python3.x中
raw_input() 和 input() 进行了整合，仅保留了input( )函数。

a = '123456'

b =
input("username:")

if b == a :            # 如果b的输入数据等于a存储的数据，打印”right“

print("right")

else:                  # 否则打印”wrong“

print("wrong")

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

print(int())                # 不传入参数时，得到结果0

print(int(0.5))             # 去掉小数部分，得到结果0

print(int(3))               # 得到结果3

print(int('0xa',16))       
# 十六进制数“0xa”转换成十进制整数，得到结果10

print(int('00010',2))      
# 二进制数“00010”转换成十进制整数，得到结果2

来判断一个对象是否是一个已知的类型，返回布尔值。类似 type()。

a =
2

print(isinstance(a,int))                   #  True

print(isinstance(a,str))                   # 
False

print(isinstance(a,(str,tuple,dict)))      #  False

print(isinstance(a,(str,tuple,int)))       # 是元组其中的一个则返回True

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。  　　

isinstance() 会认为子类是一种父类类型，考虑继承关系。  　　 
如果要判断两个类型是否相同推荐使用 isinstance()。**

示例：**

1 class A:

2     pass

3

4 class B(A):

5     pass

6

7 print(isinstance(A(),A))    # True

8 print( type(A()) == A
)     # True

9

10 print(isinstance(B(),A))    # True

11 print( type(B()) == A )     # False  
--type()不考虑继承关系

用于判断参数class是否是类型参数classinfo的子类，是则返回True，否则返回False。

语法：issubclass(class,classinfo)。

1 class a:

2    
pass

3 class b(a):     # b继承了a，即b是a的子类

4    
pass

5

6 print(issubclass(a,b))    # 判断 a 是 b 的子类？

7 # False

8 print(issubclass(b,a))    # 判断 b 是 a 的子类？

9 # True

用来生成迭代器。list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器，然后可以对获取到的迭代器不断用next()函数来获取下条数据。iter()函数实际上就是调了可迭代对象的 __iter__ 方法。

# 注意：当已经迭代完最后一个数据之后，再次调用next()函数会抛出 StopIteration的异常，来告诉我们所有数据都已迭代完成。

1 it = [1,2,3]

2 it_list = iter(it)

3

4 print(next(it_list))

5 # 1

6 print(next(it_list))

7 # 2

8 print(next(it_list))

9 # 3

10 print(next(it_list))

11 # StopIteration

返回对象（字符、列表、元组等）长度或元素个数。

len()方法返回对象（字符、列表、元组等）长度或元素个数。

print(len('1234'))              # 字符串，返回字符长度4

print(len(['1234','asd',1]))    # 列表，返回元素个数3

print(len((1,2,3,4,50)))        # 元组，返回元素个数5

print(len(12))                  # 注意：整数类型不适用，否则报错

TypeError: object of type 'int' has no len()

用于将元组转换为列表。

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

print( list((1,2,3)))           # [1, 2, 3]

接收函数f和list，并通过把函数f依次作用在list的每个元素上，得到一个新的list并返回。

1 res = map(lambda n:
n*2,[0,1,2,3,4,5])    # 使用 lambda 匿名函数

2 for i in res:

3     print(i)

4

5 # 返回以下数据：

6 # 0

7 # 2

8 # 4

9 # 6

10 # 8

11 # 10

1 # 提供了两个列表，对相同位置的列表数据进行相加

2

3 a = map(lambda x,y :
x+y,[1,2,3,4,5],[2,4,6,8,10])

4 for i in a:

5     print(i)

6

7 # 返回以下数据：

8 # 3

9 # 6

10 # 9

11 # 12

12 # 15

返回给定参数的最大值，参数可以为序列。

print("max(10,20,30):" , max(10,20,30) )

max(10,20,30): 30

print("max(10,-2,3.4):" , max(10,-2,3.4) )

max(10,-2,3.4): 10

print("max({'b':2,'a':1,'c':0}):" , max({'b':2,'a':1,'c':0}) )  
# 字典，默认按key排序

max({'b':2,'a':1,'c':0}): c

返回给定参数的最小值，参数可以为序列。

print("min(10,20,30):" , min(10,20,30) )

min(10,20,30): 10

print("min(10,-2,3.4):" , min(10,-2,3.4) )

min(10,-2,3.4): -2

print("min({'b':2,'a':1,'c':0}):" , min({'b':2,'a':1,'c':0}) )  
# 字典，默认按key排序

min({'b':2,'a':1,'c':0}): a

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

1 # 首先获得Iterator对象:

2 it = iter([1,2,3,4,5])

3

4 # 循环:

5 while True:

6     try:

7         # 获得下一个值:

8         x =
next(it)

9         print(x)

10    
except StopIteration:

11        
break

12    
# 遇到StopIteration就退出循环

将一个整数转换成八进制字符串。

print( oct(10) )          # 0o12

print( oct(255) )         # 0o377

print( oct(-6655) )       # -0o14777

用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

f =
open("test1.txt","w",encoding="utf-8")    # 创建一个file

print(f.write("abc"))

f =
open("test1.txt","r",encoding="utf-8")    # 读取文件数据

print(f.read())

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

# 把字符 b（长度为1的字符串）作为参数在ascii码中对应的字符打印出来

print( ord('b') )    # 返回：98

print( ord('%') )    # 返回：37

返回x的y次方的值。

注意：pow()通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

# 通过内置的方法直接调用

print( pow(2,2) )          #  2的二次方

# 4

print( pow(2,-2) )         #  2的负二次方

0.5

1 # 导入math模块

2

3 import math

4

5 print(math.pow(3,2))   # 3的负二次方

6 # 9.0

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

print( abs(-45) )           # 45

print("Hello World!")      
# Hello World!

print([1,2,3])              # [1, 2, 3]

可创建一个整数列表，一般用在 for 循环中。语法：range(start, stop[, step])

for i in range(10):

print(i)            # 依次打印数字0-9

for a in range(0,10,2):    
# 步长为2

print(a)            # 打印0,2,4,6,8

for b in range(10, 0, -2): 
# 步长为-2

print(b)            # 打印10,8,6,4,2

会对参数序列中元素进行累积。在Python3 ，reduce()被放置在functools模块里，如果想要使用它，需要先引入functools模块。

import functools

a =
functools.reduce(lambda x,y:x+y,[1,2,3])

print(a)           # 6 ， 即从1加到3

b =
functools.reduce(lambda x,y:x+y,range(10))

print(b)           # 45 ， 即从0加到9

将对象转化为供解释器读取的形式。返回一个对象的 string 格式。

r =
repr((1,2,3))

print( r )              # (1, 2, 3)

print( type(r) )        # 

dict
= repr({'a':1,'b':2,'c':3})

print( dict )   
# {'c': 3, 'a': 1,
'b': 2}

print( type(dict) )    #

返回一个反转的迭代器。 reversed(seq)要转换的序列，可以是 tuple, string, list 或 range。

rev
= reversed( [1,2,3,4,5] )       # 列表

print(list(rev))

[5, 4, 3, 2, 1]

rev1
= reversed( "school" )        
# 元组

print(tuple(rev1))

('l', 'o', 'o', 'h', 'c', 's')

rev2
= reversed(range(10))          # range

print(list(rev2))

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

返回浮点数x的四舍五入值。（除非对精确度没什么要求，否则尽量避开用round()函数）

print( round(4.3))         # 只有一个参数时，默认保留到整数

# 4

print( round(2.678,2))     #  保留2位小数

#  2.68

print( round(5/3,3))     #  运算表达式并保留3位小数

#  1.667

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

1 a = set('school')

2 print(a)            # 重复的被删除，得到结果：{'o', 'c', 's', 'l', 'h'}

1 b = set([1,2,3,4,5])

2 c = set([2,4,6,8,10])

3

4 print(b & c)     # 交集，得到结果为{2, 4}

5 print(b | c)     # 并集，得到结果为{1, 2, 3, 4, 5, 6, 8, 10}

6 print(b - c)     # 差集，得到结果为{1, 3, 5}

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

a =
slice("school")

print(a)            # slice(None, 'school', None)

对所有可迭代的对象进行排序（默认升序）操作。

# 对列表进行排序

print(sorted([1,2,5,30,4,22]))    # [1, 2, 4, 5, 22, 30]

# 对字典进行排序

dict
= {23:42,1:0,98:46,47:-28}

print( sorted(dict) )                     # 只对key排序

[1, 23, 47, 98]

print( sorted(dict.items()) )             # 默认按key进行排序

[(1, 0), (23, 42), (47, -28), (98, 46)]

print( sorted(dict.items(),key=lambda x:x[1]) )      # 用匿名函数实现按value进行排序

[(47, -28), (1, 0), (23, 42), (98, 46)]

# 利用key进行倒序排序

test1
= [1,2,5,30,4,22]

r_list
= sorted(test1,key=lambda x:x*-1)

print(r_list)                     # [30, 22, 5, 4, 2, 1]

# 要进行反向排序，也可以通过传入第三个参数 reverse=True：

test2
= [1,2,5,30,4,22]

print(sorted(test2,reverse=True))    # [30, 22, 5, 4, 2, 1]

将对象转化为string格式。

1 a = 
str((1,2,3))

2 print(a)            # 打印a，得到结果(1, 2, 3)

3 print(type(a))      # 打印a的类型，得到结果

对参数进行求和计算。

print( sum([1,2,3]) )        #  6

print( sum([1,2,3],4) )      #  列表计算总和后再加4，得到结果10

print( sum( (1,2,3),4 ) )    #  元组计算总和后再加4，得到结果10

将列表转换为元组。

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

print( tuple([1, 2, 3]))     # (1,2,3)

如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

print(type(1))                   #

print(type("123"))               #

print(type([123,456]))           #

print(type( (123,456) ) )        #

print(type({'a':1,'b':2}) )      #

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

1 a = [1,2,3]

2 b = [4,5,6]

3 c = [7,8,9,10]

4

5 for i in zip(a,b):

6     print(i)

7

8 # 返回结果：

9 # (1, 4)

10 # (2, 5)

11 # (3, 6)

12

13 print(list(zip(a,b)))       # list() 转换为列表

14 # [(1, 4), (2, 5), (3, 6)]

15

16 print(list(zip(b,c)))       # 元素个数与最短的列表一致

17 # [(4, 7), (5, 8), (6, 9)]

18

19 a1,a2 = zip(*zip(a,b))      #  用zip(*)解压

20 print(list(a1))         # [1, 2, 3]

21 print(list(a2))         # [4, 5, 6]

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

__import__('decorator')

# 返回结果如下：

# in
the bar

the func run time is 3.000171661376953

# _首先获得Iterator对象:

_it = iter([1,2,3,4,5])

# _循环:

_while True:

    try:

        # _获得下一个值:

_x = next(it)

        print(x)

    except StopIteration:

        **break

**# 遇到StopIteration就退出循环

Python常用的关键字

and , or 为逻辑关系用语，Python具有短路逻辑，False and 返回 False 

   不执行后面的语句， True or 直接返回True，不执行后面的语句

而列表本身包含的是变量，例：

所以

from引用模块时会用到，例：

golbal为全局变量，但当单个函数中出现同一变量名时，在单个函数中为局部变量

with被用来处理异常

紧跟with后面的语句被求值后，返回对象的enter()方法被调用，这个方法的返回值将被赋值给as后面的变量，此处为file 

当with后面的代码块全部被执行完后，将调用前面返回对象的exit()方法

实际上，在with后面的代码块抛出任何异常时，exit()方法被执行。 

正如例子所示，异常抛出时，与之关联的type，value和stack trace传给exit()方法， 

因此抛出的ZeroDivisionError异常被打印出来了。

开发库时，清理资源，关闭文件等等操作，都可以放在exit方法当中。

均为循环语句，使用while时要注意成立条件，防止陷入死循环 

for in 遍历

断言，声明其布尔值必须为真的判定，如果发生异常就说明表达示为假。 

可以理解assert断言语句为raise-if-not，用来测试表示式，其返回值为假，就会触发异常。

pass是空语句，为了保证程序结构的完整性， 

pass不做任何事情，一般用作 占位语句 

当你编写程序部分内容还没想好，可用pass语句占位

yield的意思是生产，返回了一个生成器对象，每个生成器只能使用一次

一个带有 yield的函数就是一个generation，他和普通函数不同，生成一个generator看起来像函数调用，但不会执行任何函数代码，直到对其调用.next()（在 for 循环中会自动调用 next()）才开始执行 

虽然执行流程仍按函数的流程执行，但每执行到一个
yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。

send() 与next()

Python break语句用来终止循环，用在while和for循环中！！直接跳出 整个 循环 

嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码

break是跳出整个循环，continue是跳出当前循环

如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。 

如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。 

如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

触发异常 

raise
[Exception[,args[,traceback]]] 

语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。 

该参数是可选的，如果不提供，异常的参数是”None”。 

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。

raise 触发异常后，后面的代码就不会再执行

die函数，打印错误信息

exec 用来执行储存在字符串或文件中的Python语句 

exec是一条语句将字符串str当成有效的python代码来执行 

eval与execfile是pytho内置函数 

eval(str[globals[locals]])函数将字符串str当成有效的python表达式来求值，并提供返回计算值

execfile(filename)函数可以用来执行文件

from os.path import exists 

exists(file)将文件名字符串作为参数，如果文件存在返回True，否则返回False

return 是函数返回值

lambda 只是一个表达式，定义了一个匿名函数，起到函数速写的作用 

由于lambda只是一个表达式，它可以直接作为python 列表或python 字典的成员，比如

map(function, sequence) 

对sequence中的item 依次执行 function，将执行结果组成list返回 

单个参数

多个参数，要求函数接受多个参数

reduce(function, sequence,
starting_value) 

对sequence中的item顺序迭代调用function，如果有starting_value， 

还可以作为初始值调用，例如可以用来对List求和

---

还有不足的的地方，望见谅