彩世界开奖app官网-彩世界平台官方网址(彩票平台)
做最好的网站
来自 计算机编程 2019-12-07 01:24 的文章
当前位置: 彩世界开奖app官网 > 计算机编程 > 正文

Python基础-map/reduce/filter彩世界开奖app官网

详细内容请参见廖雪峰官方网站,此处只是局地摘抄,体会与练习的coding。

 

from functools import reduce
def fn(x, y):
    return x * 10   y
def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
reduce(fn, map(char2num, '13579'))
13579
    # 测试:
    output = filter(is_palindrome, range(1, 1000))
    print('1~1000:', list(output))
    if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33,
                                                      44, 55, 66, 77, 88, 99, 101, 111, 121,
                                                      131, 141, 151, 161, 171, 181, 191]:
        print('测试成功!')
    else:
        print('测试失败!')

 

小结

filter()的效能是从五个行列中筛出切合条件的因素。由于filter()行使了惰性总括,所以唯有在取filter()结果的时候,才会真正筛选并每便回到下一个筛出的因素。

彩世界开奖app官网 1

  1. Python内建的filter()函数用于过滤连串。

    map()类似(可参照 Python 高阶函数 -- map/reduce),filter()也收到叁个函数和二个队列。和map()差别的是,filter()把传播的函数依次功用于每一个成分,然后依照重临值是True还是False调控封存依然遗弃该因素。

    诸如,在八个list中,删掉偶数,只保留奇数,可以如此写:

    def is_odd(n):
        return n % 2 == 1
    
    list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
    # 结果: [1, 5, 9, 15]
    

     

  2. 用filter求素数

    计算素数的叁个办法是埃氏筛法,它的算法明白起来比较轻松:

    首先,列出从2千帆竞发的有所自然数,构造一个系列:

    2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

    取种类的率先个数2,它必然是素数,然后用2把体系的2的倍数筛掉:

    3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

    取新系列的率先个数3,它料定是素数,然后用3把类别的3的翻番筛掉:

    5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

    取新系列的首先个数5,然后用5把种类的5的倍数筛掉:

    7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

    接踵而来筛下去,就足以得到全数的素数。

    用Python来落到实处那个算法,能够先布局四个从3发端的奇数种类:

    def _odd_iter():
        n = 1
        while True:
            n = n   2
            yield n
    

    留意那是二个生成器,何况是叁个然而种类。(关于生成器,请参照他事他说加以考察廖雪峰的另风流浪漫篇小说)

    下一场定义二个挑选函数:

    def _not_divisible(n):
        return lambda x: x % n > 0
    

    末尾,定义四个生成器,不断重回下多少个素数:

    def primes():
        yield 2
        it = _odd_iter() # 初始序列
        while True:
            n = next(it) # 返回序列的第一个数
            yield n
            it = filter(_not_divisible(n), it) # 构造新序列
    

    以此生成器先回去第一个素数2,然后,利用filter()软磨硬泡发出筛选后的新的行列。

    由于primes()也是叁个可是系列,所以调用时须求设置叁个退出循环的口径:

    # 打印1000以内的素数:
    for n in primes():
        if n < 1000:
            print(n)
        else:
            break
    

    注意到Iterator是惰性总括的类别,所以大家得以用Python表示“全体自然数”,“全体素数”那样的队列,而代码特轻便。

  3. 练习
    回数是指从左向右读和从右向左读都是均等的数,例如12321909。请利用filter()筛选出回数:

    # -*- coding: utf-8 -*-
    def is_palindrome(n):
        s = str(n)
        count = 0
        length = len(s)
        half = int(length/2) #eg. 1234321 ->half num:3
        flag = True
        while count< half:
            if s[count] == s[length-count-1] :
                count  =1
                continue
            else:
                flag=False
                break
        return flag
    

用filter求素数

  计算素数的七个艺术是埃氏筛法,它的算法驾驭起来特别轻便:

   首先,列出从2初始的装有自然数,布局二个体系:

    2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

   取系列的率先个数2,它一定是素数,然后用2把种类的2的翻番筛掉:

    3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

   取新种类的率先个数3,它肯定是素数,然后用3把连串的3的倍数筛掉:

    5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

   取新类别的首先个数5,然后用5把体系的5的倍数筛掉:

    7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

   不断筛下去,就能够获取全体的素数。

     用Python来贯彻这些算法,能够先结构三个从3起头的奇数系列:

#用filter求素数
#可以先构造一个从3开始的奇数序列:(从3开始的偶数序列都不是素数)

def _odd_iter():
    n=1
    while True:
        n =2
        yield n         #构造一个生成器,并且是一个无限序列

 

  瞩目那是一个生成器,並且是二个最为系列

   然后定义三个筛选函数:

#定义一个筛选函数
def _not_divisible(n):
    return lambda x:x%n >0 

#Lambda表示生成一个匿名函数
#带有一个参数的Lambda表达式和对应的非匿名函数:

#举例:
#    def f(n):  
#        return lambda x: x / n  
#print ( f(1)(2) )   # n=1; x=2  

 

  最后,定义叁个生成器,不断重回下叁个素数:

#最后,定义一个生成器,不断返回下一个素数
def primes():
    yield 2            #先返回第一个素数2,然后利用filter()函数不断产生筛选后的新序列
    it=_odd_iter()
    while True:
        n=next(it)    #取出序列的第一个数
        yield n        #返回序列的第一个数

        it=filter(_not_divisible,it)    #此处用_not_divisible()函数去作用it列表中的每一个数(设为x),
        #则函数实际的模样为_not_divisible(n)(x),函数所执行的操作为:x%n >0,当可以整除时,丢弃,当不能整除时,筛选出来

  

  这些生成器先回去第叁个素数2,然后,利用filter()不停爆发筛选后的新的行列。

   由于primes()也是一个然则系列,所以调用时索要设置叁个退出循环的条件

#打印1000以内的素数:        
def main():
    for n in primes():
        if n<1000:
            print(n)
        else:
            break


if __name__=='__main__':
    main()

'''
如果我们是直接执行某个.py文件的时候,该文件中那么”__name__ == '__main__'“是True,
但是我们如果从另外一个.py文件通过import导入该文件的时候,
这时__name__的值就是我们这个py文件的名字而不是__main__。

这个功能还有一个用处:调试代码的时候,在”if __name__ == '__main__'“中加入一些我们的调试代码,
我们可以让外部模块调用的时候不执行我们的调试代码,但是如果我们想排查问题的时候,
直接执行该模块文件,调试代码能够正常运行
'''    

  

  注意到Iterator是惰性总括的系列,所以大家得以用Python表示“全部自然数”,“全部素数”那样的队列,而代码非常简洁。

 

 

map函数的帮助和益处:

python基础——filter函数

  

  Python内建的filter()函数用于过滤连串。

  map()类似,filter()也收到叁个函数和二个行列。和map()不等的是,filter()把传播的函数依次成效于种种成分,然后根据再次来到值是True还是False调节封存依然放任该因素

  举个例子,在一个list中,删掉偶数,只保留奇数,能够那样写:

#在一个list中,删掉偶数,只保留奇数

def is_odd(n):
    return n%2==1

L1=filter(is_odd,[1,2,3,4,5,6,7,8,9,10,15])
print(list(L1))
#输出:[1,3,5,7,9,15]

  把五个行列中的空字符串删掉,能够这样写:

#把一个序列的空字符串删掉
def not_empty(s):
    return s.strip()

L2=filter(not_empty, ['A', '', 'B', 'C', '  '])
print(list(L2))
#输出结果:['A','B','C']

'''
strip()函数说明:
----------------------------------------------------------------------
s.strip(rm)        删除s字符串中开头、结尾处,位于 rm删除序列的字符
s.lstrip(rm)       删除s字符串中开头处,位于 rm删除序列的字符
s.rstrip(rm)      删除s字符串中结尾处,位于 rm删除序列的字符
注意:
1. 当rm为空时,默认删除空白符(包括'n', 'r',  't',  ' ')
-----------------------------------------------------------------------
'''

 

   可见用filter()其意气风发高阶函数,关键在王芸确得以达成多少个“筛选”函数。

  注意到filter()函数重返的是一个Iterator,也正是多个惰性系列,所以要逼迫filter()变成总计结果,需求用list()函数获得全部结果并回到list

  1. 函数逻辑更是明显,参数‘f’就标识了对成分的操作
  2. map是高阶函数,能够推行抽象度更高的演算  

练习

  回数是指从左向右读和从右向左读都是平等的数,譬如12321909。请利用filter()滤掉非回数:

#练习
'''
回数是指从左向右读和从右向左读都是一样的数,例如12321,909。
请利用filter()滤掉非回数:
'''

def is_palindrome(n):
    return str(n)==str(n)[::-1]        #将输入的数字转为字符串,将翻转前和翻转后的进行比较,如果一致,表示满足回数

print('1-15000的回数有:')    
print(list(filter(is_palindrome,range(1,15000))))

  运营结果:

  彩世界开奖app官网 2

 

但是假使要把类别[1, 3, 5, 7, 9]改动来整数13579reduce就能够派上用途:

 

那几个事例本人没多大用途,可是,若是考虑到字符串str也是多个行列,对上边的例子稍加改换,协作map(),大家就足以写出把str转换为int的函数:

佚名函数的花样:

class map(object):
    """
    map(func, *iterables) --> map object

    Make an iterator that computes the function using arguments from
    each of the iterables.  Stops when the shortest iterable is exhausted.
    """

Python内建的filter()函数用于过滤种类。

二、 reduce

map(卡塔尔国传入的率先个参数是f,即函数对象自己。由于结果r是一个IteratorIterator是惰性体系,因而通过list()函数让它把全数种类都总结出来并赶回四个list。

 三、filter

def prod(l):
    return reduce(lambda x, y: x * y, l)
l = [1, 2 ,3, 4, 5]
print(prod(l))
120
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.
    """

譬喻说对二个行列求和,就可以用reduce实现:

from functools import reduce

def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

def str2int(s):
    return reduce(lambda x, y: x * 10   y, map(char2num, s))
list(filter(lambda x: x % 2 == 1, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 3, 5, 7, 9]

可见用filter()那一个高阶函数,关键在苏降雨确落到实处三个“筛选”函数。

小练习:

from functools import reduce
def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str_split(s):
    s1, s2 = s.split('.')
    return s1, s2
def str2int_1(s1):
    return reduce(lambda x, y: x * 10   y, map(char2num, s1))
def str2int_2(s2):
    return (reduce(lambda x, y: x * 10   y, map(char2num, s2)))/pow(10, len(s2))
def str2float(s):
    s1, s2 = str_split(s)
    res = str2int_1(s1)   str2int_2(s2)
    return res
a = str2float('123.456')
print(a)
123.456
from functools import reduce
def add(x, y):
    return x   y
reduce(add, [1, 3, 5, 7, 9])
25

 

from functools import reduce
def fn(x, y):
    return x * 10   y
reduce(fn, [1, 3, 5, 7, 9])
13579

Python内置函数,用法及表明如下:

list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

reduce把叁个函数成效在三个队列[x1, x2, x3, ...]上,这一个函数必得选取八个参数,reduce把结果一而再再三再四和体系的下一个要素做积攒总括,其作用就是:  

def is_odd(n):
    return n % 2 == 1
list(filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 3, 5, 7, 9]

  3. 利用mapreduce编纂四个str2float函数,把字符串'123.456'调换到浮点数123.456:  

注意到filter()函数重临的是叁个Iterator,相当于多少个惰性类别,所以要强迫filter()完了计算结果,要求用list()函数获得全部结果并回到list。

from functools import reduce

def str2int(s):
    def fn(x, y):
        return x * 10   y
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(fn, map(char2num, s))

map()函数接受五个参数,二个是函数,一个是Iterablemap将盛传的函数依次功效到行列的每一个成分,并把结果作为新的Iterator返回。  

def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

 

实例:

当然求和平运动算能够平昔用Python内建函数sum(),没供给接收reduce

例如表达,比方我们有二个函数f(x卡塔尔=x2,要把那一个函数作用在多个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上,就足以用map()得以完结如下:

#使用lambda匿名函数
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))    
[1, 4, 9, 16, 25, 36, 49, 64, 81]
def not_empty(s):
    return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
['A', 'B', 'C']

用filter求素数

计算素数的几个办法是埃氏筛法,它的算法明白起来特别简单:

首先,列出从2发端的保有自然数,构造二个种类:

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取系列的率先个数2,它自然是素数,然后用2把类别的2的倍数筛掉:

3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新系列的首先个数3,它一定是素数,然后用3把类别的3的翻番筛掉:

5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新系列的首先个数5,然后用5把类别的5的倍数筛掉:

7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

不唯有筛下去,就足以博得全部的素数。

用Python来实现那几个算法,能够先布局五个从3早先的奇数体系:

def _odd_iter():
    n = 1
    while True:
        n = n   2
        yield n

小心那是三个生成器,而且是一个最佳系列。

然后定义贰个筛选函数:

def _not_divisible(n):
    return lambda x: x % n > 0

末段,定义一个生成器,不断重回下贰个素数:

def primes():
    yield 2
    it = _odd_iter()    #初始序列
    while True:
        n = next(it)    #返回序列的第一个数
        yield n
        it = filter(_n

那个生成器先重回第叁个素数2,然后,利用filter()不断发出筛选后的新的类别。

由于primes()也是一个特别类别,所以调用时索要设置贰个退出循环的标准:

#打印100以内的素数
for n in primes():
    if n < 100:
        print(n)
    else:
        break

2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

注意到Iterator是惰性总结的队列,所以大家能够用Python表示“全部自然数”,“全体素数”那样的行列,而代码特别简洁。

小练习:

  1. 回数是指从左向右读和从右向左读都以同风姿浪漫的数,譬如12321909。请利用filter()滤掉非回数:

    list(filter(lambda x: str(x) == str(x)[::-1], range(1,1000))) [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, 959, 969, 979, 989, 999]

  思路:先将int数字类型调换为str字符串类型,然后相比原字符串和取反后的字符串是还是不是等于来重回值。

  

  

参照他事他说加以侦察资料:

廖雪峰的官方网站

赞助非常大,特别谢谢!

  

  

  

  

  

  

  

  

  

  

  

  

  2. Python提供的sum()函数能够接收二个list并求和,请编写四个prod()函数,能够担当三个list并应用reduce()求积:

reduce(lambda x, y : x   y, [1, 3, 5, 7, 9])
25
def reduce(function, sequence, initial=None): # real signature unknown; restored from __doc__
    """
    reduce(function, sequence[, initial]) -> value

    Apply a function of two arguments cumulatively to the items of a sequence,
    from left to right, so as to reduce the sequence to a single value.
    For example, reduce(lambda x, y: x y, [1, 2, 3, 4, 5]) calculates
    ((((1 2) 3) 4) 5).  If initial is present, it is placed before the items
    of the sequence in the calculation, and serves as a default when the
    sequence is empty.
    """
    pass

同样能够投入无名函数:

一、map

无名氏函数完毕:

  1. 利用map()函数,把客商输入的不专门的职业的英语名字,变为首字母大写,其余小写的行业内部名字。输入:['adam', 'LISA', 'barT'],输出:['Adam', 'Lisa', 'Bart']: 

    list(map(lambda x: x.capitalize(), ['adam', 'LISA', 'barT'])) ['Adam', 'Lisa', 'Bart']

reduce(lambda x, y: x * y, [1, 2, 3, 4, 5])
120
reduce(lambda x, y: x * 10   y, [1, 3, 5, 7, 9])
13579
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

  无名函数完结:

把一个类别中的空字符串删掉,能够那样写:

收拾成一个str2int的函数正是:

list(filter(lambda x: x and x.strip(), ['A', '', 'B', None, 'C', ' ']))
['A', 'B', 'C']

无名氏函数达成:

 

例如,在三个list中,删掉偶数,只保留奇数,可以这么写:

  

仍是可以够用lambda函数进一层简化成:

map(卡塔尔国作为高阶函数,事实上它把运算准则抽象了,由此,大家不光能够测算轻易的f(x卡塔尔(英语:State of Qatar)=x2,还足以测算任性复杂的函数,举例,把那一个list全部数字转为字符串:

map()类似,filter()也吸取二个函数和叁个类别。和map()不等的是,filter()把传播的函数依次成效于每一个成分,然后依照重返值是True还是False调整封存照旧丢掉该因素。

本文由彩世界开奖app官网发布于计算机编程,转载请注明出处:Python基础-map/reduce/filter彩世界开奖app官网

关键词: Python filter()函数