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。

用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表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。

练习

　　回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用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))))

　　运行结果：

小结

　　filter()的作用是从一个序列中筛出符合条件的元素。由于filter()使用了惰性计算，所以只有在取filter()结果的时候，才会真正筛选并每次返回下一个筛出的元素。