s14 第4天 关于python3.0编码 函数式编程 装饰器 列表生成式 生成器 内置方法

标签：模块   关联   list   面向对象   rabl   集合   sed   作用   返回   

python3 编码默认为unicode，unicode和utf-8都是默认支持中文的。

如果要python3的编码改为utf-8，则或者在一开始就声明全局使用utf-8

#_*_coding:utf-8_*_

或者将字符串单独声明：

a = "中文".encode("utf-8")

函数式编程

函数式编程中的函数指代的是数学中的函数。

函数式编程输入如果确定，则输出一定是确定的。函数中并没有很多逻辑运算

python是一个面向对象的语言，只是一部分支持函数式编程。

装饰器：

定义：本质是一个函数，装饰其他函数，为其他函数增加附加功能

原则：

1、不能修改被装饰的函数的源代码

2、不能修改被装饰的函数的调用方式

实现装饰器的知识准备：

1、函数即"变量"

定义函数的过程实际是将函数体以字符串的形式保存进内存的过程，当函数()时才是调用执行函数。

因此函数的定义：

def 函数名（）：

　　函数体

实际等价于

函数名= “函数体”

因此函数名就是一个变量名。

可以作为一个参数传递给另一个函数

2、高阶函数

a：把一个函数名当做实际参数传递给另一个函数

可以在不修改函数的源代码的情况下实现新功能

def bar():

    print("in the bar")

def new_func(func):

    print("new_func")

    func()

    print("after")

原来调用：bar()

新功能调用为：new_func(bar) ,就增加新功能了，但是改变了原函数的调用方法

b：返回值中包含函数名

不修改原函数的调用方式情况下实现新功能

def bar():

    print("in the bar")

def new_func(func):

    print("new_func")

    func()

    print("after")

    return func

bar = new_func(bar)

bar()     # 为改变原函数的调用方式

返回结果

new_func   # new_func功能

in the bar # new_func功能

after # new_func功能

in the bar # bar功能

3、嵌套函数

在一个函数的函数体内用def去定义一个新函数

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

装饰器的写法：

1、普通装饰器

def bar():

    print("in the bar")

def test(func):

    def  new_func():

    print("new_func")

    func()

    print("after")

    return new_func

@test

bar()  

2、装饰器传递参数：

def bar():

    print("in the bar")

def test(func)

    def new_func(*args,**kwargs):

        print("new_func")

        func(*args,**kwargs)

        print("after")

    return new_func

@test

bar("liubo",30)

3、装饰器带参数，即可以在装饰器内做一些判断：

import time

def decorator(type):

    def outer(func):

        if type=="1":

            definner(*args,**kwargs):

                start_time=time.time()

                ret=func(*args,**kwargs)

                stop_time=time.time()

                print("func running time is %s" % (stop_time-start_time))

                return ret

            return inner

        else:

            def inner(*args,**kwargs):

                print("your input is wrong")

            return inner

    return outer

print("请输入type：")

type=input(">>>")

@decorator(type)

def f1(name,age):

    time.sleep(3)

    print("your name is{},age is{}".format(name,age))

f1("liubo",30)

列表生成式

a = [i*2 for i in range(10)]

生成的a为

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

改列表生成器等价于

a = []

for i in range(10):

    a.append(i*2)

print(a)

列表生成器可以使代码很简洁，任何针对i的for循环都可以写为[i的处理 for循环]的格式

当连续调用2次列表生成器对同一个列表时，结果并不会叠加2次的数据，而是第二次的数据会覆盖第一次的数据

a = [i*2 for i in range(10)]

a = [i*3 for i in range(10)]

print(a)

结果

[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

生成器：

如果执行一个循环的结果非常巨大，而我们只用其中一部分内容，那么多余的数据就是无用的。因此我们需要一种工具在执行循环时，每次循环生成一个数据，而之前的数据会释放，而后面的数据并没有生成，不会占地方。这种工具就是生成器。

上面提到的列表生成式，实际就是在生成时就将列表里的元素全部加载进内存的。

如果：(i*2 for i in range(10))，这样就变成了一个生成器，当输入这个命令时，内存中并没有生成任何元素，只是增加了一个生成器

因此获取生成器中的元素就不能用类似列表的切片的方式获取。

生成器只有在调用时才会生成相应的数据，调用可以使用for循环来生成，也可以使用__next__()方法获取下一个元素。而生成器只有调用时保留当前值，因此生成器无法取上一个值。实际for循环就是在for内部反复的调用next方法

如何生成一个生成器？

一个裴波那契数列的生成器：

def fib(max):

    n,a,b = 0,0,1

    while n < max:

        yield b

        a,b = b,a+b

        n+=1

    return "---done----"

f = fib(10) # 创建生成器
 

此时f就是一个生成器，那么我要应用这个函数中元素就需要使用next的方式调用。

print(f.__next__())

print(f.__next__())

print(f.__next__())

从上面的例子我们可以看到，生成器就是在函数中出现了yield关键字的函数，当函数运行时，遇到yield函数会暂停，并且返回yield后面的值，这样每次我们调用__next__()方法时，程序都会返回当前运行的结果。而return的内容就是异常时产生的消息

生成器的好处

1、节约内存外

2、可以中断数据的生成去做其他的事，然后再返回到生成器中

print(f.__next__())

print("....") # 中断生成器

print(f.__next__()) # 再次进入生成器

print("xxx") #再次中断生成器

print(f.__next__())

通过__next__()方法，当超过了生成器的元素数量时，就会以异常结束，异常的提示就是程序最后返回的值

StopIteration: ----done----        # 异常

那么如果需要避免这个异常，则需要将异常抓出

g = fib(6)

while True:

    try:  # 如果正常，则尝试循环

        x = next(g)

        print("g:",x)

    except StopIteration as e:    # 如果出现了StopIteration ，则按下面执行

        print("Generator retrun value:",e.value)  # e.value就是出错的返回值，此处为"---done----"

        break

调用一个生成器

def f1():

    x = 0

    while x < 10:

        yield x  # 第一次调用next会生成0

        x += 1 # 第二次next会先加1 然后输出1

f2 = f1()    # 首先定义f2，调用f1函数。此时相当于从f2进入了f1函数

print(f2.__next__())  # 之后的每次调用都是从f2 = f1()这里进入的，因此会依次输出0-4

print(f2.__next__())

print(f2.__next__())

print(f2.__next__())

print(f2.__next__())

如果如下

print(f1().__next__())  # 这样相当于每次都是从f1从新进入，因此每次输出都是0。因为每次都是重新调用函数

print(f1().__next__())

print(f1().__next__())

print(f1().__next__())

print(f1().__next__())

在调用生成器的函数中，除了next方法，还有一个send方法。

next方法仅仅是唤醒生成器的yield，让他开始生成元素，但是如果yield没有返回值，则返回值为None。

send方法唤醒yield，同时给yield传递值。

例如

在生成器函数中

baozi = yield

上面这个函数，取一个变量等于yield，程序 运行到此会暂停，但是yield为空，因此如果我用next方法下面调用baozi这个变量，值为空。

但是如果我在调用send方法，则这个值就会被send发送进来。

def cus(name)

    print("%s 开始吃包子" % name)

    baozi = yield # 包子赋值给yield，但是并没有返回值，这里的作用是停下来同时接收send的值给baozi

    print("%s 的包子已经被我吃了" % baozi) # 此处却需要调用baozi这个变量。

那么如果我需要baozi这个变量有值，就需要这样调用：

c = cus("liubo")  # 创建生成器并命名为c

c.__next__() # 首先要让生成器运行到yield。

c.send("韭菜馅") # 调用send方法，将"韭菜馅"这个字符串传递给yield，并向下执行

生成器单线程的并行效果 执行案例

import time

def cus(name):

    print("%s 开始吃包子" % name)

    while True:

        baozi = yield # 包子赋值给yield，但是并没有返回值

        print("{}:{} 个包子已经被我吃了".format(name,baozi)) # 此处却需要调用baozi这个变量。

def producer(name):

    c1 = cus("c1") # 创建生成器

    c2 = cus("c2")

    c1.__next__() # 让生成器执行到yield，同时也打印cus函数的第一句话，代表c1已准备好

    c2.__next__()

    for i in range(1,4):

        time.sleep(1)

        print("{}：我做了2个包子".format(name))

        time.sleep(1)

        c1.send(i) # 将i传递给c1，i将会被传递给baozi变量以便打印

        time.sleep(1)

        c2.send(i)

producer("liubo")

上述程序，将使一个厨师和两个食客三个程序同时运行（但实际是串行的）

迭代器

可直接作用于for循环的数据类型：

1、集合数据类型，例如list,tuple,dict,set,str等

2、生成器，包括带yield的生成器

可以直接作用于for循环的对象统称为可迭代对象，Iterable

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

可以使用isinstance()，判断一个对象是否为Iterable对象

form collections import Iterator

isinstance((x for x in range(10)),Iterator) # isinstance(对象，类型) 判断对象是否为特定类型

可迭代对象不一定是迭代器（list，tuple，dict），但是可以使用iter()函数将其变为迭代器

a = [11,22,33] # 可迭代对象 不是迭代器

b = iter(a) # 就是一个迭代器了，可以用b.__next__()调用下一个元素

迭代器在python代表一个数据流，是一个惰性运算，即只有当用到这个值时才生成这个值，因此迭代器可以代表一个无穷大的序列。

可迭代对象在创建之初即需要创建所有的元素，迭代器的长度是未知的，但是可迭代对象的长度却是已知的。因此可迭代对象不能是迭代器，只能通过iter()函数转换。

内置方法

匿名函数

函数的目的是为了重复调用，为此建立函数在内存中占用空间，但是如果这个函数仅调用一次这个占用的空间就被浪费了。因此引出了匿名函数。

lambda函数即匿名函数，因为这个函数并未像其他函数一样通过def func（）的方式创建了一个func的函数，他并没有创建函数名，因此当还行一次后就没有对应的变量与之关联，其占用的内存空间也就会被回收。

def func(n):
    print(n)

这个函数的lambda写法为

lambda n:print(n)

执行时可以

(lambda n：print(n))(5)

a = lambda n : print(n)

a(5)

A = lambda n:print(n) # 这里的A是一个函数

A = （lambda n : print(n)）(5) # 这里的A是匿名函数的结果，传递了n = 5给匿名函数后的return

但是lambda只能执行简单的操作，比如三元运算

a = lambda n ： print("n<3") if n<3 else print("n>3") # 相当于return 返回了一个三目运算

a(5)

软件目录开发规范

因此如果一个文件的绝对路径为：E:\Atm\bin\atm.py，我需要将E:\Atm路径追加到python模块调用的环境变量中，那么需要这样写

base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(base)

s14 第4天 关于python3.0编码 函数式编程 装饰器 列表生成式 生成器 内置方法

标签：模块   关联   list   面向对象   rabl   集合   sed   作用   返回   

原文地址：http://www.cnblogs.com/LB-BK/p/6275695.html