python 内置函数 装饰器

一、内置函数

1.compile

compile(source, filename, mode[, flags[, dont_inherit]])

用来编译一段字符串的源码，结果可以生成字节码或者AST（抽像语法树），字节码可以使用函数exec()来执行，而AST可以使用eval()来继续编译。

>>> str = "for i in range(0,10): print(i)"
>>> c = compile(str,'','exec')
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str2 = "3*3 + 4*4"
>>> c2 = compile(str2, '', 'eval')
>>> eval(c2)
25

2.exec

exec(object[, globals[, locals]])

参数object是一个字符串的语句或者一个编译过的语句的对象名称,参数globals是全局命名空间，用来指定执行语句时可以访问的全局命名空间；参数locals是局部命名空间，用来指定执行语句时可以访问的局部作用域的命名空间。如果参数globals和locals忽略，就会使用调用时所处的命名空间。这两个参数都要求是字典形式来说明命名空间。

exec没有返回值

>>> exec('if True: print(100)')
100
>>> exec('''
x = 200
if x > 100:
    print(x + 200)
''')
400

3 eval

eval(expression, globals=None, locals=None)

该函数是用来动态地执行一个表达式的字符串，或者compile函数编译出来的代码对象。参数expression是一个表达式字符串，或者表示编译出来代码对象的名称；参数globals是全局命名空间，可以指定执行表达式时的全局作用域的范围，比如指定某些模块可以使用。如果本参数缺省，就使用当前调用这个函数的当前全局命名空间；参数locals是局部作用域命名空间，是用来指定执行表达式时访问的局部命名空间。

>>> x = 1
>>> print eval('x+1')
2

4 divmod

divmod(a, b)

求余函数，返回它们相除后的的商和余数组成的元组。

>>> divmod(10,3)
(3, 1)
>>> 

5 max

max(iterable, *[, key, default])

返回可迭代的对象中的最大的元素，或者返回2个或多个参数中的最大的参数,key 指定比较的键。

>>> li = [11,11,33,11,44,44,55]
>>> max(li, key=li.count)
11

6 round

round(number[, ndigits])

返回浮点数 number 四舍五入到小数点之后 ndigits 位的结果。如果省略ndigits，该参数默认为零。

>>> round(2.345)
2
>>> round(2.345,2)
2.35

7 isinstance

isinstance(object, classinfo)

如果参数object 是参数classinfo 的一个实例；或者是其一个（直接的、间接的或者virtual）子类的实例，返回真。

>>> isinstance(li,list)
True
>>> 

8 locals

提供基于字典访问局部变量的方式。

每个函数都有着自已的名字空间，叫做局部名字空间，它记录了函数的变量，包括函数的参数

和局部定义的变量。

def foo(arg, a):
	x = 1
	y = 'xxxxxx'
	for i in range(10):
		j = 1
		k = i
	print locals()
#调用函数的打印结果
foo(1,2)
#{'a': 2, 'i': 9, 'k': 9, 'j'终端: 1, 'arg': 1, 'y': 'xxxxxx', 'x': 1}

9 map

map(function,iterable)

对于迭代对象的每个元素都执行第一个参数中的函数

>>> def func(x):
	x = x + x
	return x
>>> list(map(func,li))
[2, 4, 6, 8, 10]
>>> 

10 filter

filter(function, iterable)

对于迭对象中的没个元素都去执行以一个元素中的函数，如果结果为True,则返回

>>> li
[1, 2, 3, 4, 5]
>>> list(filter(lambda x: x> 3, li))
[4, 5]

11 range 

range(start, stop[, step])

返回一个起于start,到stop,步长为step的序列，start默认是0，step默认是1。

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(10,1,-2))
[10, 8, 6, 4, 2]

12 zip

zip(*iterables)

将多个序列中索引相同的项，组成元组，如果序列长度不同，则以长度短的为标准。

>>> l1 = [1,2,3,4,5]
>>> l2 = ['a','b','c','d']
>>> zip(l1, l2)
<zip object at 0x0000000003419948>
>>> list(zip(l1, l2))
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

二、装饰器

1.预备知识

#### 第一波 ####
def foo():
    print 'foo'
 
foo     #表示是函数
foo()   #表示执行foo函数
 
#### 第二波 ####
def foo():
    print 'foo'
 
foo = lambda x: x + 1
 
foo()   # 执行下面的lambda表达式，而不再是原来的foo函数，因为函数 foo 被重新定义了

2.装饰器开始

记住装饰器最容易理解的两句话：

1.自动执行outer函数并且将下面的函数名f1当作参数传递。

2.将outer函数的返回值，重新赋值给f1。

第一步 最简单的函数，准备附加额外功能

>>> def outer():
        print("outer called.")
        
>>> outer()
outer called.

第二步：使用装饰函数在函数执行前和执行后分别附加额外功能

>>> def outer(func):
    print("before outer called.")
    func()
    print("  after outer called.")
    return func
>>> def f1():
    print(" f1 called.")
    
>>> f1 = outer(f1)
before outer called.
 f1 called.
  after outer called.

第三步：使用语法糖@来装饰函数

>>> def outer(func):
    print("before outer called.")
    func()
    print("  after outer called.")
    return func
>>> def f1():
    print(" f1 called.")
>>> @outer
    def f1():
	print('f1 called')
	
before outer called.
f1 called
after outer called.

第四步：使用内嵌包装函数

>>> def outer(func):
        def inner():
            print("before func called.")
            func()
            print("  after func called.")
            # 不需要返回func，实际上应返回原函数的返回值
        return inner
>>> 
>>> @outer
def f1():
	print('f1 called')
	
>>> f1()
before func called.
f1 called
after func called.

第五步：对带参数的函数进行装饰

>>>def outer(func):
      def inner(a, b):
          print("before func called.")
          ret = func(a, b)
          print("  after func called. result: %s" % ret)
          return ret
      return inner
 
>>>@outer
def f1(a, b):
    print(" f1(%s,%s) called." % (a, b))
    return a + b
>>>f1()
before func called.
f1(a,b) called
after func called.

 第六步：对参数数量不确定的函数进行装饰

>>>def outer(func):
      def inner(*args, **kwargs):
          print("before func called.")
          ret = func(*args, **kwargs)
          print("  after func called. result: %s" % ret)
          return ret
      return inner
 
>>>@outer
def f1(a, b):
    print(" f1(%s,%s) called." % (a, b))
    return a + b
>>>@outer
def f2(a, b, c):
    print(" f2(%s,%s,%s) called." % (a, b, c))
    return a + b + c
>>>f1()
before func called.
f1(a,b) called
after func called.
>>>f2()
before func called.
f1(a,b,c) called
after func called.

来自为知笔记(Wiz)