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

Python函数进阶:闭包、装饰器、生成器、协程

时间:2020-01-19 12:51:34      阅读:59      评论:0      收藏:0      [点我收藏+]

标签:函数定义   括号   app   注册   nonlocal   for语句   deb   生成器   write   

返回目录

 

本篇索引

(1)闭包

(2)装饰器

(3)生成器

(4)协程

 

  (1)闭包

闭包(closure)是很多现代编程语言都有的特点,像C++、Java、JavaScript等都实现或部分实现了闭包功能,很多高级应用都会依靠闭包实现。 一般专业文献上对闭包的定义都比较拗口,比如:“将组成函数的语句和这些语句的执行环境打包在一起时,得到的对象称为闭包。”

其实,简单来说,你可以将闭包看成是一个轻载的类,这个类只有一个函数方法,并且只有为数不多的几个成员变量。 闭包的优点是:实现起来比类稍微轻巧一点(意思就是可以少敲一些代码),并且运行速度比类要快得多(据说约快50%)。下面是一个定义闭包的简单例子:

def foo(x, y):
    def hellofun():
        print(‘hellofun x is %d, y is %d.‘ %(x,y))
    return hellofun
    
a = foo(1,2)
b = foo(30,40)

a()
b()

# 运行结果为:
hellofun x is 1, y is 2.
hellofun x is 30, y is 40.

上例中,foo就定义了一个闭包,它将内部定义的函数hellofun返回(但并不运行这个函数), 同时将入参x,y作为以后hellofun要运行时的环境,隐式地与hellofun打包一起返回。 因此,a=foo(1,2) 语句的作用就是:生成一个闭包对象a,这个对象是可作为函数运行的,且其内部含有隐式的成员变量x=1和y=2。 当后面执行 a() 时,会真正运行这个hellofun函数,并且其运行时的环境就是闭包中的:x=1和y=2。

 

● 查看闭包中变量的内容

续上例:

print(a.__closure__)
print(a.__closure__[0].cell_contents)
print(a.__closure__[1].cell_contents)

# 运行结果为:
(<cell at 0x0000022B7436CFD8: int object at 0x00007FFDB0E37100>, <cell at 0x0000022B74386288: int object at 0x00007FFDB0E37120>)
1
2

 

● 用闭包实现计数器的例子

def countdown(n):
    def next():
        nonlocal n    # Python3可使用nonlocal关键字,用于声明n为next()函数外部的变量
        r = n
        n -= 1
        return r
    return next
    
next = countdown(10)
while True:
    v = next()
    if not v: break

 

 

  (2)装饰器

装饰器(decorator)是一个函数,其主要用途是包装另一个函数。它可以在不改动原函数的情况下,增强原函数的功能。 相当于给原函数加装了一个增强包。我们来看一个例子:

def square(x):
    return x*x

上面是一个计算平方的函数,但是功能非常简单。我们可以通过为其加装装饰器的方法,增强其功能,比如:为这个函数增加打印计算结果的功能。 代码如下:

# 定义装饰器函数
def print_result(func):
    def callf(*args, **kwargs):
        r = func(*args, **kwargs)
        print(‘The result is %d.‘ %r)
        return r
    return callf
    
# 原函数定义
def square(x):
    return x*x

# 用装饰器函数装饰原函数
square = print_result(square)

我们先不管装饰器函数的定义,先看最后一行:装饰器的原理就是,将原来的函数square作为参数传递给我们新定义的装饰器函数, 再偷偷将square这个名称替换成我们自己定义的装饰器函数print_result中返回的callf函数。这样,当用户执行比如 square(2) 语句时, 并不是在执行原来的square函数,而是在运行我们的 callf(2)。

接下来我们再来看装饰器函数中的内容,print_result(func)实际上是定义了一个闭包,和前面的例子中将数据x,y作为闭包环境数据传进来不同, 这里将整个square()函数定义作为闭包环境数据传了进来,好在Python中万物皆对象,函数定义本质上也是一个对象, 所以将它作为数据传进来也是可以的。

然后在运行callf(2)的时候,将入参"2"通过(*args, **kwargs)参数原封不动地传给了func(*argc, **kwargs)去运行, 而这个func就是闭包对象中的的数据(即原square函数的定义),在运行完func函数之后(其实就是运行了square(2)之后),增加了一句print打印功能, 最后再将func函数返回的结果r再原封不动地返回出去。整个过程就好像给原函数square套了一个壳,故称为装饰器。

运行装饰后的函数:

y = square(2)
print(y)

# 运行结果为:
The result is 4.
4

 

可以用特殊语法符号@来简写装饰器,以上代码的简写形式为:

# 定义装饰器函数
def print_result(func):
    def callf(*args, **kwargs):
        r = func(*args, **kwargs)
        print(‘The result is %d.‘ %r)
        return r
    return callf
    
# 用@装饰原函数
@print_result
def square(x):
    return x*x

 

● 使用多个装饰器

可以对一个原函数使用多个装饰器,其装饰先后顺序为从下到上、从内到外:

@dec1
@dec2
@dec3
def square(x):
    pass
    
# 相当于:
def square(x):
    pass
square = dec1(dec2(dec3(square)))

 

● 接收参数的装饰器

装饰器也可以接收参数,用法如下:

@eventhandler(‘BUTTON‘)
def handle_button(msg):
    pass
    
@eventhandler(‘RESET‘)
def handle_reset(msg):
    pass

接收参数的装饰器的语义如下:

temp = eventhandler(‘BUTTON‘)
handle_button = temp(handle_button)

接收参数的装饰器通常用于函数的回调注册等用途,下面是以上代码的完整例子:

# 事件处理程序装饰器
event_handlers = {}
def eventhandler(event):
    def register_function(f):
        event_handlers[event] = f
        return f
    return register_function
    
@eventhandler(‘BUTTON‘)
def handle_button(msg):
    pass

当运行带参数的装饰器语句@eventhandler(‘BUTTON‘),首先会运行 temp = eventhandler(‘BUTTON‘),运行完后temp指向的是 register_function(f)函数,并且其环境数据event为‘BUTTON‘。接下来运行 handle_button = temp(handle_button), 这相当于运行:register_function(handle_button),在这个函数中,会把handle_button函数(即入参f)放入全局字典event_handlers中, 然后再把这个handle_button函数原封不动地返回去,返回给全局名称handle_button。

这个装饰器的用法和我们前面见过的普通装饰器的功能稍有不同,它并没有通过偷换handle_button名称来增强handle_buttton()函数的功能, 仅仅是将handle_button函数放入了全局字典event_handlers,做了一个类似注册的工作。handle_button()函数还是原来那个函数。

 

 

 

  (3)生成器

只要在函数中使用了 yield 语句,这个函数就称为生成器(generator)。生成器本身的概念很简单,理解起来也不难, 但是可以用生成器完出很多花样、写出一些执行效率很高又看上去比较优雅的代码,比如管道、协程等等。

 

● 基本概念

这里我们先讲生成器的基本概念:调用生成器函数时,函数将返回一个生成器对象,但本身并不运行。 当第一次调用__next__()方法时,函数从头开始运行,直到第一次遇见yield语句,当运行完这句 yield语句后,函数会暂停运行,并将yield语句指定的返回值返回。 之后,可以在这个生成器对象上反复调用__next__()方法,每次调用,都从刚才暂停的地方开始继续运行,并运行到下一个yield语句再次暂停。 最后,当函数中所有数据都迭代完毕,再无yield语句可用时,会引发一个StopIteration异常。用户如捕获到这个异常,可知生成器已迭代完毕。

下例为定义并使用一个生成器的基本方法:

# 定义生成器
def countdown(n):
    print(‘Start counting‘)
    while n > 0:
        yield n
        n -= 1

使用生成器

>>> c = countdown(3)
>>> print(c.__next__())
Start counting
3
>>> print(c.__next__())
2
>>> print(c.__next__())
1
>>> print(c.__next__())
引发StopIteration异常

上例中,函数countdown()定义了一个生成器。当运行 c = countdown(3) 后,这个生成对象被赋值给了c,在这个生成器对象中,保存了函数运行时内部的上下文变量数据。

(1)当第1次调用 c.__next__()语句时,函数从头开始运行,并运行到第一个 yield n 语句暂停,根据yield n 语句的指示, 将 n(此时值为3)作为返回值返回。

(2)当第2次调用 c.__next__()语句时,函数从刚才暂停的地方(即 yield n的后一句:n -= 1)开始运行,并运行到再次遇到 yield n 为止。 此时函数再次暂停,并将 n(此时值为2)作为返回值返回。

(3)当第3次调用 c.__next__()语句时,函数继续从刚才暂停的地方(即 n -= 1)开始运行,并运行到再次遇到 yield n 为止。 此时函数再次暂停,并将 n(此时值为1)作为返回值返回。

(4)当第4次调用 c.__next__()语句时,函数继续从刚才暂停的地方(即 n -= 1)开始运行。当这句 n -= 1 运行完毕后,n的值为0,再回到上面的while语句时,不再满足 while n > 0 的循环要求, 因此,函数结束while循环,运行到函数结束位置。此时,生成器引发StopIteration异常。

 

● 在for循环中使用生成器

上例仅用于说明生成器的基本概念。一般我们在使用生成器时,通常不会像上面那样手动去调用__next__()方法, 而是通过一个for语句让Python自动调用生成器的__next__()方法,并自动捕获StopIteration异常来结束for循环。

下例为上面的countdown生成器的通常使用方法:

for i in countdown(3):
    print(i)

# 运行结果为:
3
2
1

 

● 用生成器实现类似管道的功能

管道是Linux/Unix操作系统中的一种强大的数据流处理方式,它可以将输出程序和输入程序分开实现,非常符合模块化的思想。 而Python的生成器,可以在程序内部模仿这种风格,使得输出函数只要考虑如何输出,输入函数只要考虑如何处理输入的内容, 而将它们的交互糅合交给外部用户去安排。

考虑如下一个任务:假设有一个日志文件 log.txt,这个文件由操作系统负责写入,每当有新用户登录时, 操作系统会在这个文件最后追加一行,记录新登录用户的用户名和登录时间。现在需要编一个Python程序持续监视这个日志文件 (每秒查看一次这个日志文件),每当发现用户名Tom登录时,在屏幕上打印这条登录信息。

如果不使用生成器的话,一般会使用类似如下代码实现这个功能:

import os
import time

def grep(line, searchtxt):
    if searchtxt in line:
        print(line)

def tail(f):
    f.seek(0, os.SEEK_END)    # 移动到文件尾
    while True:
        line = f.readline()   # 如果没有新的内容,readline()会返回空
        if not line:
            time.sleep(1)
            continue

        grep(line, ‘Tom‘)

        
# 下面是用户使用代码        
f = open(‘log.txt‘)
tail(f)

代码不难,上例中实现了2个函数,tail()函数负责每秒查看一次日志文件log.txt,若无新内容,则睡眠1秒钟;若发现日志文件中有新内容, 则调用grep()函数进行判断,grep()函数若发现新行中有特定的文本(本例中是‘Tom‘),则使用print在屏幕上打印这行内容。

上面代码的问题在于,输入输出函数没有做到严格分开,如果现在变更一下需求,需要监视用户名为Jerry的用户并打印这条登录信息, 那么势必要去更改 tail() 函数的内部实现(第16行改成 grep(line, ‘Jerry‘)),这就不符合模块化编程的思想了。

如果使用生成器来编程,就可以很好地做到这一点,代码如下所示:

import os
import time

# 输出函数只管输出
def tail(f):
    f.seek(0, os.SEEK_END)
    while True:
        line = f.readline()
        if not line:
            time.sleep(1)
            continue
            
        yield line
        
# 输入函数只管处理输入内容
def grep(linegtr, searchtxt):
    for line in linegtr:
        if searchtxt in line:
            yield line
        
        
# 下面是用户使用代码
f = open(‘log.txt‘)
logtxt = tail(f)                   # logtxt是一个生成器对象,每次
result = grep(logtxt, ‘Jerry‘)     # result也是一个生成器对象
for line in result:
    print(line)

上述代码中,logtxt = tail(f) 产生了一个生成器,这个生成器永远不会耗尽数据(当没有新数据时会睡眠,但生成器永不会耗尽而引发StopIteration异常), 所以当grep()函数中用 for line in linegtr 去迭代这个logtxt生成器时,当有数据时,会使用后面的 if 语句进行判断,当符合条件即用 yield line 语句返回这行文本; 当没有数据时进程就睡眠。

而grep()函数也是一个生成器,也是永不耗尽。所以当下面的用户代码用 for line in result 语句去迭代这个 result 生成器时, 若grep有数据返回,则用print()函数打印这行内容,若没有则睡眠。

以上代码做到了输出函数与输入函数的分开实现,将交互糅合的工作交给了用户来处理。使用生成器的关键好处是: 它可以使函数返回一些内容,又不退出函数。

 

● 关闭生成器

生成器在所有数据迭代完后会被自动关闭,一般不需要手动去关闭。但在一些特殊情况下,也可以通过调用close()方法去手动关闭生成器。

c = countdown(3)
c.__next__()
c.close()     # 手动关闭生成器

c.__next__()  # 报错!close()后再调用__next__()方法会引发StopIteration异常

在生成器内部,在yield语句上出现GeteratorExit异常时,就会调用close()方法,也可以在生成器中手动去捕获这个异常, 以执行一些清理操作,如下例所示:

def countdown(n):
    try:
        while n > 0:
            yield n
            n -= 1
    except GeneratorExit:
        print(‘The current n is %d‘ %n)

 

● 生成器表达式

我们以前学过“列表推导”(list comprehension),可以很方便地根据条件来生成一个列表。其缺点也很明显,如果数据量很大, 会在内存中生成一个庞大的列表,很吃内存资源。

对于大量数据,更好的方法是使用“生成器表达式”(generator expression),它的功能与列表推导相同,但不会立即生成一个大列表, 而是生成一个生成器表达式对象,在后面的迭代过程中,每次仅动态生成需要的部分。

“生成器表达式”的语法同“列表推导”非常相似,只是用圆括号替代方括号,其语法格式如下:

(expression for item1 in iterable1 if condition1
            for item2 in iterable2 if condition2
            ...
            for itemN in iterableN if conditionN)

下例打开一个文件,并打印其中所有以 # 开头的注释行

f = opeon(‘a.txt‘)
comments = (t for t in lines if t[0] == ‘#‘)      # comments为生成器表达式对象
for c in comments:
    print(c)

上例中,运行 comments = (t for t in lines if t[0] == ‘#‘) 语句时,仅仅生成了一个生成器表达式对象,并没有真正去读取整个文件。 而在后面的 for 循环中,才真正去按需读取文件的各行并进行过滤,每一行都是按需生成的。

由于不需要把整个文件都加载到内存中,这对于读取GB级大小的文件时是非常高效的。

最后需要注意的是,生成器表达式不是列表,你不能对它进行下标索引,也不能进行任何诸如append()之类的列表常规操作。 如果需要,你可以使用内置的list()函数,将生成器表达式对象转换成真正的列表。

 

● 声明式编程

利用生成器表达式,可以写出很多紧凑和高效的代码。假设我们有下面一个文本文件stationery.txt, 第1列为商品名称、第2列为单价、第3列为数量:

pen,20.5,3
ruler,3.0,10
eraser,2.5,8

现在我们要对每行的第2列和第三列求乘积,并将所有行的乘积求和算出总价,传统的实现代码是类似下面这个样子的:

total = 0
for line in open(‘stationery.txt‘):
    fields = line.split(‘,‘)
    total += float(fields[1]) * float(fields[2])
print(total)

而如果使用生成器表达式,可以像这样写:

lines = open(‘stationery.txt‘)
fields = (line.split(‘,‘) for lien in lines)          # fields 为第1个生成器表达式对象
print(sum( float(f[1]) * float(f[2]) for f in fields ))   # sum()函数中的内容为第2个生成器表达式对象

这样写的代码比上面的传统写法更紧凑,而且执行速度往往更快。由于在写生成器表达式的时候,仅仅是说明了生成迭代规则, 并不真正运行迭代(真正的迭代运行交给下面的for去完成),有点像写配置文件,故称为“声明式编程”(declarative programming)

生成器表达式还可以与数据库查询语句(SQL select)结合使用,写出非常紧凑的复杂功能代码:

sum(price*qty for price,qty in 
      cursor.execute(‘select price, qty from stationery‘) 
          if price*qty >= 100)

 

 

 

  (4)协程

前面的生成器函数只能单向返回数据,而不能在挂起期间动态接收新的数据。其实,只要在生成器函数中将yield反过来用, 将yield放在等号的右边,并加上括号,就可以接收数据。以这种方式使用yield语句的函数称为协程(coroutine)

就如同前面我们说过“闭包”像一个轻载的类,“协程”就像一个轻载的线程。可以将协程当成一个任务,能发给它数据, 让协程根据收到的数据去完成任务,协程完成任务后会自己挂起;直到下次再收到数据,协程会再次激活运行, 运行完任务后继续挂起……很像一个线程的行为(普通线程是收到特定的信号(Signal)激活,运行完任务后自动挂起,但需要操作系统来调度)。

 

● 协程的基本用法

下例定义了一个简单的协程 receiver:

def receiver():
    print("The receiver is running")
    while True:
        n = (yield)   # 获取外部发给协程的数据
        print("Got %s" %n)

使用协程:

>>> r = receiver()        # 生成一个协程
>>> r.__next__()          # 调用__next__()是必须的,为的是让函数运行到 yield 前一句
The receiver is running
>>> r.send(‘Hello‘)
Got Hello
>>> r.send(1)
Got 1

上面的例子中,receiver()是一个协程,其功能是每次收到新数据后将其打印到屏幕。当第一次调用完__next__()方法后, 函数将运行到n = (yield) 语句的右半部分,暂停并返回(这里返回None)。之后每次通过send()方法给这个协程发数据后, 函数恢复运行(注意:这里会继续运行n = (yield)语句的左半部分,将收到的数据赋值给n),一直运行到下一个yield语句为止。

 

● 给协程上装饰器

在协程使用过程中,一个常见的错误是:经常会忘记写__next__()调用。我们可以写一个装饰器来自动完成这一个功能:

# 定义装饰器coroutine
def coroutine(func):
    def start(*args, **kwargs):
        g = func(*args, **kwargs)
        g.__next__()
        return g
    return start
    
@coroutine
def receiver():
    print("The receiver is running")
    while True:
        n = (yield)    
        print("Got %s" %n)

使用协程:

>>> r = receiver()            # 生成一个协程          
The receiver is running       # 用户不必自己调用__next__(),装饰器已帮我们自动调用好了
>>> r.send(‘Hello‘)
Got Hello
>>> r.send(1)
Got 1

 

● 关闭协程

协程一般不会自己退出,会永远执行下去(回忆对比一下生成器:会在迭代数据耗尽后自己退出)。 可以使用 close() 方法显式关闭协程,当协程被关闭后,再给协程发数据会引发StopIteration异常。

>>> r = receiver()  
>>> r.close()
>>> r.send(‘Hello‘)    # 报错!close()后再调用send()方法会引发StopIteration异常

同生成器一样,close()操作将在协程内部引发GeneratorExit异常。

另外,还可以在协程对象上使用throw()方法在协程内部引发异常,以这种方式引发的异常将在协程中当前执行的yield语句处出现, 协程可以选择捕捉这个异常并以正确的方式处理它们。顺带提一句,不要通过其他线程给当前线程的协程发送throw()异常。

 

● 使用协程同时收发数据

协程可以使用yield一句同时接收数据和发出返回值,用法如下:

def receiver():
    print("The receiver is running")
    result_list = []
    while True:
        n = (yield result_list)     # 接收数据的同时,将result_list 放入返回值
        result_list.append(n)
        print("Got %s" %n)

使用结果:

>>> r = receiver()  
>>> print(r.__next__())
The receiver is running
[]
>>> print(r.send(‘a‘))
Got a
[‘a‘]
>>> print(r.send(‘b‘))
Got b
[‘a‘, ‘b‘]

(1)上例中,先手动调用__next__()执行到第1个yield语句,这时仅执行这个 yield 语句的右半部分 (yield result_list)。 这个右半部分会返回 result_list列表(此时为空列表)。

(2)当之后调用 r.send(‘a‘) 时,协程继续运行 n = (yield result_list) 语句的左半部分,将收到的 ‘a‘ 赋值给n, 然后运行到下一个 n = (yield result_list) 语句的右半部分,此时返回的 result_list 的值为[‘a‘]。

(3)之后再次调用 r.send(‘b‘) 时,分析方法同上类似。

 

● 使用协程实现并发

在理解了上面协程的基本用法后,我们来看如何用协程实现并发编程。使用协程,可以轻松实现几百几千个轻载任务的并发。 一个典型的应用是处理网络连接,如果有几百个用户连接进来,用协程可以轻松地进行异步处理,相比之下, 如果开几百个线程来处理的话,开销就太大了。

由于网络编程部分还在后面,这里先演示一个用协程处理打开若干个文件的例子,其中coroutine装饰器已在前面的例子中定义。 下面代码的功能是,用户指定一个目录和一个文件名,让程序自动去遍历查找这个目录及其子目录下有没有这个文件, 若有,则打开文件查找其中有没有含“Tom”这个字符串的行,若找到则在屏幕上打印这个行。

import os
import fnmatch

@coroutine
def find_files(target):
    while True:
        topdir, filename = (yield)
        for path, dirlist, filelist in os.walk(topdir):
            for name in filelist:
                if name == filename:
                    target.send(os.path.join(path, name))
        
@coroutine
def opener(target):
    while True:
        name = (yield)
        f = open(name)
        target.send(f)
        
@coroutine
def cat(target):
    while True:
        f = (yield)
        for line in f:
            target.send(line)
            
@coroutine
def grep(pattern, target):
    while True:
        line = (yield)
        if pattern in line:
            target.send(line)
            
@coroutine
def printer():
    while True:
        line = (yield)
        sys.stdout.write(line)
        
        
# 下面是使用协程
finder = find_files(opener(cat(grep("Tom", printer()))))

# 发送值给协程,激活协程去工作
finder.send(‘/var‘, ‘log.txt‘)       
finder.send(‘testdir1‘, ‘filea.txt‘)

下面使用协程的第一句:finder = find_files(opener(cat(grep("Tom", printer())))) 的功能是启动所有协程。 下面我们对其运行过程一步步进行分析。

(1)按顺序,最里面的printer()协程最先运行,运行到printer()中的yield语句挂起返回,返回值就是这个printer协程对象。

(2)然后将“Tom”字符串和前面这个printer()返回的协程对象作为参数,传递给grep()协程。 同样的,在grep()中也是运行到yield语句挂起返回,返回这个grep协程对象。

(3)然后再将这个grep协程对象作为入参传递给cat()协程,之后的流程也是类似的。依次一步步往外传……

(4)最后一步就是将opener协程对象作为find_files()协程的入参,生成最外层的find_files协程对象。在find_files()中, 也是运行到yield语句挂起返回,不过find_files()中的这句 topdir, filename = (yield) 语句可同时接收2个数据, 若收到数据则将它们分别赋值给topdir和filename变量。

 

之后,就可以通过调用 finder 协程对象的send()方法,给协程发数据让协程工作了。发送的顺序与刚才完全倒过来,从最外层的find_files()协程开始。

(1)当执行 finder.send(‘/var‘, ‘log.txt‘) 语句后,会激活最外层的find_files协程,它收到“目录”与“文件名”两个数据后, 执行os.walk()方法遍历整个目录树,若在目录树中找到与给定文件名相同的文件,则通过 target.send() 语句,将这个文件名(含完整路径) 发送给opener协程去打开。这里的target就是最先前find_files协程初始化的时候,传进来的opener协程对象。

(2)当opener协程收到数据后,同样也被激活,然后它执行 f = open(name) 完成打开文件的任务,再将这个文件对象 f 发送给cat协程。

(3)cat协程收到数据后,同样也被激活,然后它执行 for 语句来迭代这个文件对象,每次for迭代会返回文件中的一行, 并将这行字符串数据 line 发送给grep协程对象。

(4)grep协程收到一行字符串数据后,通过 if 语句比对这行字符串中是否含有初始化时输入的“Tom”,若有,则将这行字符串发送给printer协程。

(5)最后,当printer协程收到数据后,通过 sys.stdout.write(line) 完成在屏幕打印这行字符串的任务,之后再次运行到yield语句挂起返回。 其外层的各个协程也依次一个个挂起返回,最终完成了一次send()调用。

之后可以任意次调用finder.send()方法来搜索不同的目录和文件名。

 

 

 

 

返回目录

Python函数进阶:闭包、装饰器、生成器、协程

标签:函数定义   括号   app   注册   nonlocal   for语句   deb   生成器   write   

原文地址:https://www.cnblogs.com/initcircuit/p/12132294.html

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