码迷,mamicode.com
首页 > 编程语言 > 详细

初学python之day4

时间:2016-08-19 06:16:13      阅读:200      评论:0      收藏:0      [点我收藏+]

标签:

每天进步一点点

一、 python学习之装饰器

函数即“变量“

高阶函数:

  1,把一个函数名当做实参传递给另外一个函数(在不修改被装饰函数源代码的情况下为期添加功能)

  2,返回值中包含函数名(不修改函数的调用方法)

嵌套函数:

def test():

  def add():

......

 高阶函数+嵌套函数 组成了装饰器 ,装饰器既不会改变源代码又不改变函数的调用方式

1-1前提知识

def demo():
  print ‘demo‘

demo #表示是函数
demo() #表示执行demo函数

#函数重新定义
def demo():
  print ‘demo‘

demo = lambda x: x + 1     #lambda 是匿名函数

demo(2) # 执行下面的lambda表达式,而不再是原来的demo函数,因为函数 demo 被重新定义了

1-2装饰器用法举例

import time
def mode_q(func: object) -> object: #把test2赋给func
def deco():
st_time = time.time()
func() #即为运行 test2()
stop_time = time.time()
print("func运行时间为 %s" %(stop_time-st_time))
return deco #返回deco的内存地址

def test1():
time.sleep(2)
print("test1")

@mode_q #test2 = mode_q(test2)
def test2():
time.sleep(2)
print("test2")

test2()
输出结果为:

test2

func运行时间为 2.0

1-3 被装饰的函数有参数

1-3-1带一个参数
def w1(func):
  def inner(arg):
    ......
    func(arg)
    ......
  return inner

@w1
def f1(arg):
  print ‘f1‘


1-3-2 带两个参数
def w1(func):
  def inner(arg1,arg2):
    ......
    func(arg1,arg2)
    ......
  return inner

@w1
def f1(arg1,arg2):
  print ‘f1‘

1-3-2 带n个参数
def w1(func):
  def inner(*args,**kwargs):
    ......
    func(*args,**kwargs)
     ......
  return inner

@w1
def f1(arg1,arg2,arg3):
  print ‘f1‘

1-4 一个函数可被多个装饰器装饰
def w1(func):
  def inner(*args,**kwargs):
    ......
    func(*args,**kwargs)
    ......
  return inner

def w2(func):
  def inner(*args,**kwargs):
    ......
    func(*args,**kwargs)
    ......
  return inner

@w1
@w2
def f1(arg1,arg2,arg3):
  print ‘f1‘

 

二、 python学习之生成器

通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。

所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。

要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator:

1
2
3
4
5
6
>>> L = [x * for in range(10)]
>>> print(L)
[0149162536496481]
>>> g = (x * for in range(10))
>>> print(g)
<generator object <genexpr> at 0x1022ef630>

创建Lg的区别仅在于最外层的[]()L是一个list,而g是一个generator。

我们可以直接打印出list的每一个元素;而generator里的每一个元素我们可以通过next()函数获取:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
>>> g = (x * for in range(10))
>>> print(g)
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
>>> print(next(g))
0
1
4
9
16
25
36
49
64
81
Traceback (most recent call last):
  File "XXX", line 32in <module>
    print(next(g))
StopIteration

上面我们可以看到,每次调用next(g),就计算出g的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。

当然,我们也可以通过for循环去调取元素值:

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> g = (x * for in range(10))
>>> for in g:
>>>    print(i)
0
1
4
9
16
25
36
49
64
81

generator非常强大。如果推算的算法比较复杂,用类似列表生成式的for循环无法实现的时候,还可以用函数来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#斐波拉契数列
def fib(max):
    n, a, b = 001
    while n < max:
        print(b)
        a, b = b, a + b
        += 1
    return ‘done‘
  
fib(5)
###########打印输出###########
# 1
# 1
# 2
# 3
# 5

仔细观察,可以看出,fib函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。

也就是说,上面的函数和generator仅一步之遥。要把fib函数变成generator,只需要把print(b)改为yield b就可以了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#斐波拉契数列
def fib(max):
    n, a, b = 001
    while n < max:
        yield(b)
        a, b = b, a + b
        += 1
    return ‘done‘
  
= fib(5)
print(f)
for in f:
    print(i)
###########打印输出###########
#<generator object fib at 0x000000000110A468>
#1
#1
#2
#3
#5

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator。

generator和函数的执行流程不一样。函数是顺序执行,遇到return语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行。

上面我们会发现:用for循环调用generator时,发现拿不到generator的return语句的返回值。如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIterationvalue中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def fib(max):
    n, a, b = 001
    while n < max:
        yield b
        a, b = b, a + b
        = + 1
    return ‘done‘
= fib(6)
while True:
    try:
        = next(g)
        print(‘g:‘, x)
    except StopIteration as e:
        print(‘Generator return value:‘, e.value)
        break
####打印输出####
# g: 1
# g: 1
# g: 2
# g: 3
# g: 5
# g: 8
# Generator return value: done

生成器的特点:

1)生成器只有在调用时才会生成相应的数据;

2)只记录当前位置;

3)只有一个__next__()方法;

还可通过yield实现在单线程的情况下实现并发运算的效果:

初学python之day4

标签:

原文地址:http://www.cnblogs.com/xiaopython/p/5774381.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!