您的位置:新葡亰496net > 奥门新萄京娱乐场 > 列表生成式,内置函数和递归

列表生成式,内置函数和递归

发布时间:2019-09-15 20:26编辑:奥门新萄京娱乐场浏览(117)

    目录:

    那一个都以python的性子,不仅独有力,并且好用,合作起来使用更为庞大。

    Python学习(五)函数 —— 内置函数 lambda filter map reduce,pythonlambda

        一  内置函数    
    abs() divmod() input() open() staticmethod()
    all() enumerate() int() ord() str()
    any() eval() isinstance() pow() sum()
    basestring() execfile() issubclass() print() super()
    bin() file() iter() property() tuple()
    bool() filter() len() range() type()
    bytearray() float() list() raw_input() unichr()
    callable() format() locals() reduce() unicode()
    chr() frozenset() long() reload() vars()
    classmethod() getattr() map() repr() xrange()
    cmp() globals() max() reversed() zip()
    compile() hasattr() memoryview() round() __import__()
    complex() hash() min() set()  
    delattr() help() next() setattr()  
    dict() hex() object() slice()  
    dir() id() oct() sorted()

    exec 内置表达式

    map, filter, and reduce

      一、lambda表达式

    零、lambda

    Python 内置函数 lambda、filter、map、reduce

      Python 内置了某些对比奇特且实用的函数,使用那么些能使您的代码简洁而易读。

      下面临 Python 的 lambda、filter、map、reduce 实行开始的上学。reduce 仅提一下,递归的措施建议用循环取代。

     

    二 无名函数

    Python提供了多少个函数,使得能够实行函数式编制程序。这一个函数都兼备方便的表征,他们能够能够很平价的用python编写。
    函数式编制程序都以关于表明式的。大家能够说,函数式编制程序是一种面向表明式的编制程序。

      二、介绍多个BIF:filter()和map()

    lambda用于发生三个无名表明式,组成都部队分为:lambda ‘函数表明式’ ‘函数表明式’由一个冒号加上八个‘操作数’组成,如:

      lambda 无名函数

        lambda语句中,冒号前是参数,能够有多少个,用逗号隔绝,冒号左侧的重返值。

        lambda语句营造的实际上是三个函数对象,参谋下例来感触下 lambda 无名函数:

    1 def f(i):             # 用户自定义返回平方数
    2     return i*i
    3 print(f(3))
    4 
    5 g = lambda x : x*x    # lambda 匿名函数
    6 print(g(3))
    

        lambda 函数和平凡的函数相比较,便是省去了函数名称,同一时候那样的佚名函数,无法分享在其他地点调用,也可以有广大其余方法能够替代lambda。

        那是或不是 lambda 就从不要求了呢? 认为上,lambda 仍然有以下优势的:

          1. 省去定义函数的长河,神速定义单行的微小函数,让代码特别从简

          2. 无需复用的函数,无须定义函数名称

          3. 和 filter map reduce 结成使用

        lambda 函数可含蓄多个参数,仿照效法下方示例:

    1 def f(x,y):
    2     return x y
    3 print(f(3,4))
    4 g = lambda x,y : x y
    5 print(g(3,4))
    

        lambda 类似于C语言中的宏,是从LISP借用来的;C#3.0发端,也是有近似的表明式,关键字是=>,参考如下:

    1 var array = new int[] {2, 3, 5, 7, 9};
    2 var result = array.Where(n => n > 3);      // [5, 6, 9]
    

        

    佚名函数正是不要求显式的钦命函数

    Python提供的面向表达式的函数有:
    map(aFunction, aSequence)
    filter(aFunction, aSequence)
    reduce(aFunction, aSequence)
    lambda
    list comprehension

      三、课时21课后习题及答案

    lambda x:x*3

      filter 函数

        filter 函数会对点名系列奉行过滤操作,filter(function or None, sequence) -> filter object (list, tuple, or string in 2.x)
        filter 函数会对队列参数 sequence 中的各个成分调用 function 函数,最终回来的结果包罗调用结果为True的成分

        注意:3.x 再次来到的是一个filter object (后续的函数map也是重回object),要抬高list()等类型转变;而从前 2.x 版本的回到值类型和参数sequence的类型同样

     1 '''filter'''
     2 def is_Even(i):
     3     if(i%2==0):
     4         return True
     5     else:
     6         return False
     7 l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     8 l = filter(is_Even, l)
     9 print(l)                                  # 3.x 返回的是对象 filter object
    10 l = list(l)                               # 3.x 须做类型转换
    11 print(l)                
    12 
    13 l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    14 l = list(filter(lambda x : x%2==0, l))    # 结合lambda
    15 print(l)    
    

     

        1, lambda是无名函数的重大,lambda的简短,基本语法实在冒号(:)左侧放源函数的参数,可以七个参数,一逗号(,)隔离;冒号左侧是再次来到值。lambda语句其实重回的是叁个函数对象,假设想要对其选用,只需进行一个简单的赋值就能够。

    map
    我们对list和其余sequence所做的大规模事情之一是对各种item应用操作并募集合果。
    举个例子,能够行使for循环轻巧完毕更新list中的全数items的立异操作:

     

    冒号侧边的操作数,作为函数的参数;冒号左边的当作函数的放回值!

      map 函数

        map 函数会对点名体系做映射操作,map(function or None, sequence) ->  map object (list, tuple, or string in 2.x)

        map 函数会对队列参数 sequence 中的种种元素调用 function 函数,再次来到的结果为每贰个要素调用function函数的再次回到值

     1 '''map'''
     2 def sqr(i):
     3     return i**2
     4 l = [1,2,3]
     5 l = map(sqr,l)                                
     6 print(l)                                     # 3.x 返回的是对象 map object
     7 l = list(l)
     8 print(l)
     9 
    10 l = [1,2,3]
    11 l = list(map(lambda x : x**2, l))            # 结合lambda
    12 print(l)
    

     

    新葡亰496net 1

    >>> items = [1, 2, 3, 4, 5]
    >>> squared = []
    >>> for x in items:
        squared.append(x ** 2)
    >>> squared
    [1, 4, 9, 16, 25]
    

    *********************

    那么lambda x:x*3就等价于:

      reduce 函数

        注意:reduce 函数在 3.x 版本不是内建函数了,reduce()函数已经被从大局名字空间里移除了,它以往被停放在fucntools模块里,用的话要 先引进

         from functools import reduce 

        reduce 函数会对点名种类做迭代操作,reduce(function, sequence[, initial]) -> value

        reduce 函数中的function参数是贰个有多少个参数的函数,reduce依次从 sequence 中取三个因素,和上三次调用 function 的结果做参数再次调用function。

     1 '''reduce'''
     2 from functools import reduce                # 3.x 版本须引入
     3 def sum(x,y):
     4     return x y
     5 l = [1,2,3,4,5,6]
     6 l = reduce(sum,l)
     7 print(l)
     8 
     9 l = [1,2,3,4,5,6]
    10 l = reduce(lambda x,y:x y,l)                # 结合lambda
    11 print(l)
    12 help(reduce)                                # 查看 reduce 帮助
    

     

    —— 内置函数 lambda filter map reduce,pythonlambda Python内置函数 lambda、filter、map、reduce Python内置了一部分相比非常且实用的...

    lambda表明式的职能:

    是因为那是三个大规模的操作,实际上大家有三个放置的效劳,能够替大家做到超越四分之二的干活。
    map(aFunction,aSequence)函数将盛传的函数应用于可迭代对象中的每种item,并赶回三个富含全部函数调用结果的list。

    一、lambda表达式

    def xxx(x):  

        (1) 在编辑一些剧本时,使用lambda就足以剩下定义函数的历程,比方说只是内需写个轻巧的脚本来管理服务器,就没有必要极其定义一个函数在调用。使用lambda就能够使得代码越来越简短。

    >>> items = [1,2,3,4,5]
    >>> def sqr(x):return x ** 2
    >>> list(map(sqr,items))
    [1,4,9,16,25]
    

    *********************

      return x*3

        (2) 对于一些比较抽象而且整个程序实践下来只必要调用一五次的函数,一时候给函数起个名也是十一分头疼的事,使用lambda就无需思虑命名的难题。

    笔者们透过二个客商定义的函数应用于list的每一种item。 map调用每一个list中item上的sqr,并将装有重回值搜罗到三个新list中。因为map须要传入三个函数,所以它也刚刚是lambda常规用的地方之一:

    Python允许行使lambda关键字来创立无名氏函数。

     

        (3) 简化代码的可读性,由于阅读普通函数常常要跳到早先的def定义的职位,使用lambda函数可以省区那样的步调。

    >>> list(map((lambda x: x **2), items))
    [1, 4, 9, 16, 25]
    

    先来定义二个平日的函数:

    一、列表生成式

       2,filter():filter有三个参数,首个参数能够是二个函数也得以是None,假诺是二个函数的话,则将第4个可迭代数据里的每多少个因素作为函数的参数进行计算,吧重临True的值筛选出来。作为第三个参数为None,则间接将第贰个参数中为True的值筛选出来。

    新葡亰496net,在地方的差不离示例中,lambda函数给列表中的各种item都做了平方运算。如前所述,map是这么定义的:
    map(aFunction, aSequence)

    >>> def ds(x):
        return 2 * x   1
    
    >>> ds(5)
    11
    

    列表生成器,可以由3个部分组成,那3个从左到右的顺序是:

    新葡亰496net 2

    尽管大家照旧使用lamda作为函数,但大家能够将函数列表作为连串:

    若是应用lambda语句来定义那几个函数,就能够化为那样:

    1、表明式部分:一般为贰个表明式效能一个列表的因素;也许就该因素,不成效任何表明式 、

      3 , map():在编制程序领域,map一般叫做‘映射’来证明。map()那些松手函数也可以有七个参数,是贰个函数和四个可迭代连串,将体系的每三个要素作为函数的参数进行运算加工,直到可迭代类别每一个成分都加工实现,再次来到全部加工后的要素构成新的队列。

    def square(x):
            return (x**2)
    def cube(x):
            return (x**3)
    
    funcs = [square, cube]
    for r in range(5):
        value = map(lambda x: x(r), funcs)
        print value
    
    >>> lambda x : 2 * x   1
    <function <lambda> at 0x00000172968578C8>
    

    2、列表生成都部队分:一般为八个for循环爆发初步列表,并逐一导出成分

    新葡亰496net 3

    输出结果:

    Python的lambda表达式语法特别简洁,基本语法是在冒号(:)左边放原函数的参数,能够有四个参数,用逗号(,)隔开就可以;冒号侧面是重返值。在上头的例子中大家发掘lambda语句实在是回到二个函数对象,假若要对它进行应用,只要求开展简短的操作就能够:

    3、过滤部分:一般由一个if决断构成,条件为假的过滤掉。那一个局部可选。

      4  , sorted():排序,为局地岗位捣乱的进展有序的排列。

    [0,0]
    [1,1]
    [4,8]
    [9,27]
    [16,64]
    
    >>> g=lambda x : 2 * x   1
    >>> g(5)
    11
    

    小结一下列表生成器正是:

    新葡亰496net 4

    因为使用map等价于循环,所以大家总是能够编写制定一个通用的炫丽工具:

    上面演示lambda表明式五个参数的例证:

    [表明式部分 列表生成都部队分 过滤部分(可选)]#瞩目四个部分之间空格隔绝就可以

    三 递归

    >>> def mymap(aFunc, aSeq):
        result = []
        for x in aSeq: result.append(aFunc(x))
        return result
    
    >>> list(map(sqr, [1, 2, 3]))
    [1, 4, 9]
    >>> mymap(sqr, [1, 2, 3])
    [1, 4, 9]
    >>> 
    
    >>> def add(x,y):
        return x   y
    
    >>> add(3,4)
    7
    >>> g = lambda x , y :x   y
    >>> g(3,4)
    7
    

    例子:

      递归的定义:递归的定义是算法的范畴,本来不属于python语言的语法内容,但基本在各类编制程序语言类别教学都要讲到递归。假使通晓了递归的方法会开掘是叁个老大棒的编制程序思路。递归的补益是代码简洁,精炼。

    鉴于map是置于的,所以它一直可用,并平昔以同等的主意行事。它也许有一点品质上的益处,因为它一般比手动编码的循环越来越快。除却,map能够以更加尖端的措施采纳。譬如,在给定几个种类参数的情事下,它将竞相选取的品类作为不一致的参数发送给函数:

    lambda表明式的功用:

    [ str(i) for i in range(1, 100) if not(i%3)]

    新葡亰496net 5

    >>> pow(3,5)
    243
    >>> pow(2,10)
    1024
    >>> pow(3,11)
    177147
    >>> pow(4,12)
    16777216
    >>> 
    >>> list(map(pow, [2, 3, 4], [10, 11, 12]))
    [1024, 177147, 16777216]
    >>> 
    

    (1)Python写一些推行脚本时,使用lambda就足以省下定义函数过程,比方说大家只是必要写个简易的脚本来处理服务器时间,大家就无需特地定义三个函数然后再写调用,使用lambda就能够使得代码尤其简明。

    这么些明白顺序进度是:

    新葡亰496net 6

    如上例所示,对于四个连串,map()需求N个系列的N参数函数。在这一个例子中,pow函数在种种调用中都有五个参数。

    (2)对于一些比较空虚并且整个程序实施下来只须求调用一三遍的函数,不时候给函数起个名字也是相比较发烧的难点,使用lambda就无需考虑命名的主题材料了。

    率先由列表生成都部队分:for i in range(1, 100)逐第一行当生列表的要素,

      递归的调用:在函数内部调用全部可见的函数进度中,还足以平昔大概直接调用了该函数自个儿。

    下边是另叁个map()做三个列表成分加多的例证:

    (3)简化代码的可读性,由于平常的土冒函数阅读常常要跳到起初def定义部分,使用lambda函数能够节约那样的步调。

    各样 元素经过过滤部分:if not(i%3)检测,剖断为假的平素抛弃,

    新葡亰496net 7

    x = [1,2,3]
    y = [4,5,6]
    
    from operator import add
    print map(add, x, y)  # output [5, 7, 9]
    

     

    推断为真正再交给表明式部分:str(i) 实行管理获得新列表的因素。

     在初学者使用递归的时候最轻易出错,理论上那一个程序将会永世的秩序下去,直到耗尽全数内部存款和储蓄器财富。不过在python3中为了出于好心的护卫,对递归有暗许的奉行限制,那样您的试行代码才会停下来(暗中认可1000层)。要是你写的前后相继需求超过暗许的限制,能够本人安装递归档次的限量。若是在运用中卡在二个地点了,能够行使Ctrl C让他截至下来。

    地图调用类似于列表理利肠府达式。可是map对每一种门类利用了多少个函数调用,并非二个随意的表明式。由于这些范围,它是不太相像的工具。但是,在少数情状下,映射只怕比列表解析式越来越快,举例映射内置函数。并且map须要越来越少的编码。
    假使函数是None,则只要身份函数;要是有七个参数,则map()重回三个包罗全体迭代(一种转置操作)中相应项指标元组的列表。可迭代的参数只怕是一个类别或任何可迭代的靶子;结果三番五次三个列表。

    *******************************************

    本条流程直到for甘休循环,新列表生成。

     递归的副成效:1 递归函数可以调用本身,但每一次调用都亟需举办压栈,弹栈,保存和还原寄放器的栈的操作,在那上头是很开支时空的。

    >>> m = [1,2,3]
    >>> n = [1,4,9]
    >>> new_tuple = map(None, m, n)
    >>> new_tuple
    [(1, 1), (2, 4), (3, 9)]
    

    二、介绍五个BIF:filter()和map()

     

            2 一旦递归一旦忘记重返,大概不当的装置了回到的口径,那么在施行的递归代码会化为贰个无底洞,只进不出。(递归的口诀:递归递归,归去来兮。)

    对于Python3,我们兴许想利用itertools.zip_longest来代替:

    *******************************************

    二、过滤器(filter)

                新葡亰496net 8

    >>> m = [1,2,3]
    >>> n = [1,4,9]
    >>> from itertools import zip_longest
    >>> for i,j in zip_longest(m,n):
    ...    print(i,j)
    ... 
    1 1
    2 4
    3 9
    

     1、filter()

    过滤器有七个参数:function类型,种类

     使用迭代时微秒级的,而完结递归是考验CPU的力量了(n秒----n分钟不等)。

    zip_longest()使得迭代器聚合来自七个迭代器(m&n)的要素。

    咱俩商讨的首先个内建函数是贰个过滤器。大家天天会接触到大方的数目,过滤器的作用就显示十分首要了,通过过滤器,就能够保存你所关注的音讯,把任何不感兴趣的东西直接甩掉。那Python怎么着来促成过滤效果吗?先来寻访Python自个儿的疏解:

    1、体系是将被筛选的原来集合,function类型是制订筛选的条条框框(公式)。

     

    filter、reduce
    从名称想到所包括的意义,filter提取函数再次来到True的队列中的每一个成分。减弱函数的谋算稍微不鲜明。该功能通过提供的职能结合成分将列表减弱为单个值。 map函数是用于函数式编制程序的Python内建函数中最简便易行的函数。
    这个工具将函数应用于队列和任何迭代。filter根据作为过滤器的测量检验效能过滤出iterm,并将功用利用到item对和减弱的运作结果。因为她俩回去迭代器,范围和过滤器都亟待列表调用,以在Python 3.0中彰显全数的结果。

    >>> help(filter)
    Help on class filter in module builtins:
    
    class filter(object)
     |  filter(function or None, iterable) --> filter object
     |  
     |  Return an iterator yielding those items of iterable for which function(item)
     |  is true. If function is None, return the items that are true.
     |  
     |  Methods defined here:
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __iter__(self, /)
     |      Implement iter(self).
     |  
     |  __next__(self, /)
     |      Implement next(self).
     |  
     |  __reduce__(...)
     |      Return state information for pickling.
     |  
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
    

    2、function类型假如回去None,只怕说就是None,则连串中为值为假的将被过滤,如:

    比方说,上边包车型客车filter调用会挑选出连串中型小型于零的项目:

    轮廓意思是:filter有七个参数。第一个参数能够是一个函数也足以是None,如若是一个函数的话,则将第1个可迭代数据里的每三个要素作为函数的参数进行计算,把再次来到True的值筛选出来;借使第三个参数为None,则一贯将第一个参数中为True的值筛选出来。例如:

    filter(None,(0,0,False,11,True,1,123)),就能过滤剩下[11, True, 1, 123]

    >>> list(range(-5,5))
    [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
    >>>
    >>> list( filter((lambda x: x < 0), range(-5,5)))
    [-5, -4, -3, -2, -1]
    >>> 
    
    >>> temp = filter(None,[1,0,False,True])
    >>> list(temp)
    [1, True]
    

    瞩目到filter()函数重临的是一个Iterator,也正是三个惰性体系,所以要逼迫filter()实现总括结果,需求用list()函数获得全数结果并回到list。

    在该函数重返true的行列或迭代中的项目,结果被加多到结果列表。像map一样,那一个函数差非常的少也就是三个for循环,但它是放到的和高效的:

    选择filter(),尝试写几个筛选奇数的过滤器:

    >>> list(filter(None,(0,0,False,11,True,1,123)))

    >>> result = []
    >>> for x in range(-5, 5):
        if x < 0:
            result.append(x)
    
    
    >>> result
    [-5, -4, -3, -2, -1]
    
    >>> def odd(x):
        return x%2
    
    >>> temp = filter(odd,range(10))
    >>> list(temp)
    [1, 3, 5, 7, 9]
    

    [11, True, 1, 123]

    此处是filter()的另三个用例:找到四个列表的名不副实:

    那今后求学了lambda函数后,完全能够把上述进度转化为一行:

    3、当function类型是贰个函数时,filter会将种类中各类成分带入函数,函数返回假的要素被删除,

    a = [1,2,3,5,7,9]
    b = [2,3,5,6,7,8]
    print filter(lambda x: x in a, b)  # prints out [2, 3, 5, 7]
    
    >>> list(filter(lambda x:x%2,range(10)))
    [1, 3, 5, 7, 9]
    

    如:

    请小心,我们得以在列表驾驭上做一样的事情:

    2.map()

    >>> list(filter(lambda x:not x%2,[x for x in range(10)]))

    a = [1,2,3,5,7,9]
    b = [2,3,5,6,7,8]
    print [x for x in a if x in b] # prints out [2, 3, 5, 7]
    

    map在此间不是地图的野趣,在编制程序领域,map一般作“映射”来解说。map()那一个松开函数也会有多个参数,还是的hi一个函数和二个可迭代体系,将体系的每叁个成分作为函数的参数进行演算加工,直到可迭代种类每种成分都加工落成,重返全数加工后的成分结合的新体系。

    [0, 2, 4, 6, 8]

    reduce是Python 3.0中的functools。那是更眼花缭乱的。它接受一个迭代器来拍卖,但它本身不是一个迭代器。它回到三个纯粹的结果:

    比如:

    4、假设筛选的准则不复杂的话,列表生成式完全能够取代他:

    >>> from functools import reduce
    >>> reduce( (lambda x, y: x * y), [1, 2, 3, 4] )
    24
    >>> reduce( (lambda x, y: x / y), [1, 2, 3, 4] )
    0.041666666666666664
    
    >>> list(map(lambda x:x*2,range(10)))
    [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
    

    [x for x in range(10) if(not x%2)]

    在每个步骤中,减中将这几天产品或单位以及列表中的下一个类型传递给传入的lambda函数。暗中认可意况下,连串中的第八个门类开头化开始值。
    此间是率先个调用的for循环版本,在循环之中举行了硬编码:

     

     

    >>> L = [1, 2, 3, 4]
    >>> result = L[0]
    >>> for x in L[1:]:
        result = result * x
    >>> result
    24
    

    *******************************

    三、映射(map)

    让大家来营造我们友好的reduce版本。

    三、课时21课后习题及答案

    1、和filter类似,可是此番不是过滤,而是映射:把二个行列映射成另三个队列,映射法则由一个函数制定。 2、同样map也许有七个参数:function类型,类别,如:

    >>> def myreduce(fnc, seq):
        tally = seq[0]
        for next in seq[1:]:
            tally = fnc(tally, next)
        return tally
    
    >>> myreduce( (lambda x, y: x * y), [1, 2, 3, 4])
    24
    >>> myreduce( (lambda x, y: x / y), [1, 2, 3, 4])
    0.041666666666666664
    >>> 
    

    *******************************

    map(lambda x:x**2,range(10)),那样连串[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]就被映射成了

    大家能够接连一串字符串来做一个句子。使用迪杰Stella关于错误的着名报价:

    新葡亰496net 9

    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    import functools
    >>> L = ['Testing ', 'shows ', 'the ', 'presence', ', ','not ', 'the ', 'absence ', 'of ', 'bugs']
    >>> functools.reduce( (lambda x,y:x y), L)
    'Testing shows the presence, not the absence of bugs'
    >>> 
    
    We can get the same result by using join :
    >>> ''.join(L)
    'Testing shows the presence, not the absence of bugs'
    

    新葡亰496net 10

    细心到map()函数返回的是叁个Iterator,也正是多个惰性体系,所以要逼迫filter()完结总结结果,必要用list()函数获得全部结果并赶回list。

    咱俩也得以使用运算符来产生一样的结果:

    新葡亰496net 11

    >>> list(map(lambda x:x**2,range(10)))

    >>> import functools, operator
    >>> functools.reduce(operator.add, L)
    'Testing shows the presence, not the absence of bugs'
    

    新葡亰496net 12

    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    内置的reduce还允许在系列中的项目事先放置叁个可选的第多少个参数,以作为系列为空时的暗许结果。

    新葡亰496net 13

    列表生成式,内置函数和递归。4、假设筛选的平整不复杂的话,列表生成式完全能够代替他:

    新葡亰496net 14

    [x**2 for x in range(10)]

    新葡亰496net 15

     

     

    总结:

    1、filter和lambda结合,能够一本万利的筛选三个种类。

    2、map和lambda结合,能够一本万利的映照出新的行列。

    3、要是筛选/映射法规相比较简单,能够直接用列表生成式替代,越发便于。

    4、他们实际上都得以独家组成,发生巨大产生力。

     

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:列表生成式,内置函数和递归

    关键词: