Python3

1.上节内容回顾                                                                                                                                             

递归：

• 明确的结束条件
• 问题规模每递归一次都应该比上一次的问题规模有所减少
• 效率低

高阶函数

文件：

rb、wb、ab

一般用在不同系统之间传数据，和传视频流的时候用到，一般以这种形式打开的需要制定encoding=‘utf-8’的字符编码形式

其他：

• f.seek()
• f.tell()
• f.truncate()
• f.flush() 

2.装饰器                                                                                                                                                     

 

 定义：装饰器本质是函数，（装饰其他函数）就是为其他函数添加附加功能

原则：

• 不能修改被装饰的函数的源代码
• 不能修改被装饰的函数的调用方式

言外之意就是说被装饰的函数在装饰器前都是完全透明的

实现装饰器知识储备：

1. 函数即“变量”
2. 高阶函数

• • • 把一个函数名当做实参传给另外一个函数（不修改被装饰函数源代码的情况下为期添加功能）
    • 返回值中包含函数名（不修改函数的调用方式）

　　3.嵌套函数

一、函数的调用顺序：函数就像变量一样，在定义的时候就是把函数体赋值给函数名这样子，Python在调用函数之前，该函数一定要先被声明

def foo():
    print(foo)
    bar()
foo()
def bar():
    print(bar)
#报错，bar函数还未声明

 

 改正：

def foo():
    print('foo')
    bar()
def bar():
    print('bar')
foo()

二、 高阶函数

def bar():
    print 'in the bar'
def foo(func):
    res=func()
    return res
foo(bar)

三、嵌套函数

def foo():
    def bar():
        print 'in the bar'
 
    bar()
 
foo()

 

四、装饰器

装饰器的语法以@开头，接着就是装饰器要装饰的函数的声明

装饰器就是一个函数，一个用来包装函数的函数，装饰器在函数声明完成的时候被调用，调用之后声明的函数被换成一个被装饰器装饰过后的函数。

当函数有形参时，在装饰的函数中也需要有相应的形参；

当原函数有return返回值时，在装饰的函数中也要萹蓄有return func（args）；

函数参数固定：

def decorator(func):
    def wrapper(n):
        print('atarting')
        func(n)
        print('stopping')
    return wrapper
def test(n):
    print('in the test arg is %s'%n)
decorator(test)('alex')

函数参数不固定

def decorator(func):
    def wrapper(*args,**kwargs):
        print('starting')
        func(*args,**kwargs)
        print('stopping')
    return wrapper
def test(n,x=1):
    print('in the test arg is %s,he is %d'%(n,x))
decorator(test)('alex',x=2)

　　1.无参装饰器

import time
def decorator(func):
    def wrapper(*args,**kwargs):
        start =time.time()
        func(*args,**kwargs)
        stop = time.time()
        print('run time is %s'%(stop-start))
    return wrapper
@decorator  #test=decorator(test)
def test(list_test):
    for i in list_test:
        time.sleep(0.1)
        print('_'*20,i)
test(range(10))

　　2.有参装饰器

import time
def timer(timeout =0):
    def decorator(func):
        def wrapper(*args,**kwargs):
            start = time.time()
            func(*args,**kwargs)
            stop = time.time()
            print("run time is %s"%(stop-start))
            print(timeout)
        return wrapper
    return decorator
@timer(2)  #test=timer(2)（test）
def test(list_test):
    for i in list_test:
        time.sleep(0.1)
        print('-'*20,i)
test(range(10))

高阶函数+嵌套函数=》装饰器

举一个复杂的例子：

import time
user,passwd = 'alex','abc123'
def auth(auth_type):
    print("auth func:",auth_type)
    def outer_wrapper(func):
        def wrapper(*args, **kwargs):
            print("wrapper func args:", *args, **kwargs)
            if auth_type == "local":
                username = input("Username:").strip()
                password = input("Password:").strip()
                if user == username and passwd == password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    res = func(*args, **kwargs)  # from home
                    print("---after authenticaion ")
                    return res
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == "ldap":
                print("搞毛线ldap,不会。。。。")

        return wrapper
    return outer_wrapper

def index():
    print("welcome to index page")
@auth(auth_type="local") # home = wrapper()
def home():
    print("welcome to home  page")
    return "from home"

@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs  page")

index()
print(home()) #wrapper()
bbs()

 

 3.列表生成式，迭代器&生成器                                                                                                                                                   

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

只记录当前的位置

只有一个__next__()方法，next()

列表生成式：

需求：将列表[0,1,2,3,4,5,6,7,8,9]将列表里的每个值加1、

三种写法：

a =[0,1,2,3,4,5,6,7,8,9]
b =[]
for i in a:
    b.append(i+1)
a =b
print(a)

a = [1,2,3,4,5,6,7,8,9]
a =map(lambda x:x+1,a) #map(f(x),列表名）
for i in a:
    print(i)

a= [i+1 for i in range(10)]
for i in a:
    print(i)

第三种即就是列表生成式

生成器：

 通过列表生成式，我们可以直接创建一个列表，但是要创建100万个元素的列表，那么存储空间很庞大，因此，我们只需要生成式，它就是不必创建完整的list，从而节省大量空间，这种一遍循环一边计算的机制，称为生成器：generator

创建generetor有以下几种方法：

第一种：把列表生成式的[]改为(),就创建了一个generator

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

 

 此时g已经是一个生成器

如何一个个打印出来,用next()函数即可

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

 

generator保存的是算法，每次调用next()，就计算出g的下一个元素的值，直到计算出最后一个元素，没有更多的元素时，跑出StopIteration错误

不断调用next()方法太麻烦，因此用for循环，此种方法也不需要考虑StopIteration错误

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
...
0
1
4
9
16
25
36
49
64
81

 

 打印斐波拉契数列：

斐波拉契数列（Fibonacci）：1, 1, 2, 3, 5, 8, 13, 21, 34, ...

def fib(max):
    n,a,b=0,0,1
    while n<max:
        print(b)
        a,b=b,a+b
        n =n+1
    return 'done'

 fib函数实际上定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑很类似generator。

要把fib()变成generator，只需要把print(b)改为yield(b)即可

 def fib(max):
      n,a,b=0,0,1
      while n<max:
          #print(b)
          yield b   
          a,b=b,a+b
          n =n+1
      return ‘done' 

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

generator，在每次调用next()执行，遇到yield就返回，再次执行则从上次返回的yield语句处继续执行

data = fib(10)
print(data)

print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())

#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13

在循环过程中不断调用yield，就会不断中断，当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

把函数变成generator之后，基本不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

在用for循环调用generator时，发现拿不到generator的return语句的返回值，如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = 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

还可以使用yield实现单线程的情况下并发运算的效果

#_*_coding:utf-8_*_
__author__ = 'Alex Li'

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

#通过生成器实现协程并行运算

迭代器：

直接作用于for循环的数据类型以下几种：

一类是集合数据类型：列表(list)，元组(tuple)，字典(dict)，集合(set)，字符串(str)等

一类是generator，包括生成器和带yield的generator function。

这类可直接作用于for循环的对象统称为可迭代对象：Tterable

可以使用isinstance()判断一个对象是是否是Iterrator对象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但可以作用于for循环，还可以被next()函数不断调用并但会下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

可以被next()函数调用并不断返回下一值的对象称为迭代器：Iterator

可以使用isinstance()判断一个对象是否是Iterator对象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

由此可知：生成器都是Iterator对象，但列表、字典、字符串虽然是Iterable但不是Iterator

小结：

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，他们表示一个惰性极端的序列(即只有在需要的时候才会计算，不需要则不会计算)；

集合数据类型如：列表、字典、字符串，集合等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

如for新欢本质上是通过不断调用next()函数实现的：

 for x in [1, 2, 3, 4, 5]: pass 

实际上等价于：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

4.内置函数                                                                                                                                                           

 见博客地址：

5.软件目录结构规范