一：any与all函数

函数信息表格

函数原型	all(iterable)
参数解释	iterable	可迭代对象，参数不可为空，但iterable可空。
返回值	<class 'bool'> true 或 false。
函数说明	当 iterable中所有元素为 true 时，则返回 true 。如果当 iterable 为空时，返回 false

 

函数原型	any(iterable)
参数解释	iterable	可迭代对象，参数不可为空，但iterable可空。
返回值	<class 'bool'> true 或 false。
函数说明	当 iterable 中有元素为 true 时，则返回 true 。如果当 iterable 为空时，返回 false 。

从官方文档中，我们可以得知，all(iterable)完全与下面这段代码等价：

1 2 3 4 5

1 def all(iterable): 2     for element in iterable: 3         if not element: 4             return false 5     return true

 any(iterable)则与这段代码等价：

1 2 3 4 5

1 def any(iterable): 2     for element in iterable: 3         if element: 4             return true 5     return false

也就是说，当给定一个不为空的可迭代对象之后：

　　对于all函数，如果元素全为真则返回true，否则返回假。即只要存在为假的元素就返回假。

　　对于any函数，只要存在一个为真的元素就返回true。不存在为真的元素返回假。

另外，当可迭代对象为空时，all函数返回true，any函数返回false。这是因为iterable为空时遍历不执行，直接跳到 line 5 执行 return。

列题描述

　　任务

　　　　给你一个字符串。
　　　　　您的任务是查明字符串是否包含：字母数字字符，字母字符，数字，小写和大写字符。

　　输入格式

　　　　包含字符串的单行。

　　输出格式

　　　　在第一行中，print trueif是否包含任何字母数字字符。否则，打印false。
　　　　在第二行中，print trueif是否有任何字母字符。否则，打印false。
　　　　在第三行中，打印trueif是否有任何数字。否则，打印false。
　　　　在第四行中，print trueif是否包含任何小写字符。否则，打印false。
　　　　在第五行中，print trueif是否有任何大写字符。否则，打印false。

　　实现代码

        ----------------方法一-------------

if __name__ == '__main__':

    s = input()

    print(any(c.isalnum for c in s))

    print(any(c.isalpha for c in s))

    print(any(c.isdigit for c in s))

    print(any(c.islower for c in s))

    print(any(c.isupper for c in s))

-------------方法二--------------------

for test in ('isalnum', 'isalpha', 'isdigit', 'islower', 'isupper'):

        any(eval("c." + test + "()") for c in s)

 二：zip函数

　　zip函数是将任意个可迭代序列作为参数，将其利用拉链形式拼接起来，返回一个tuple列表

1.zip函数使用

1 2 3 4 5 6 7 8 9

x = [1, 2, 3]   y = [4, 5, 6]   z = [7, 8, 9]   xyz = zip(x, y, z) --------------------结果----------------------- [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

在结果上py2直接利用列表输出,py3中而是生成了zip生成器对象

1 2 3 4 5 6

x = [1, 2, 3] y = [4, 5, 6] z = [7, 8, 9] xyz = zip(x, y, z) u = zip(*xyz) print u

运行的结果是：

[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

一般认为这是一个unzip的过程，它的运行机制是这样的：

在运行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

那么，zip(*xyz) 等价于 zip((1, 4, 7), (2, 5, 8), (3, 6, 9))

所以，运行结果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

注：在函数调用中使用*list/tuple的方式表示将list/tuple分开（相当于zip((1,4,7),(2,5,8),(3,6,9))），作为位置参数传递给对应函数（前提是对应函数支持不定个数的位置参数）

1 2 3

x = [1, 2, 3] r = zip(* [x] * 3) print r

运行的结果是：

[(1, 1, 1), (2, 2, 2), (3, 3, 3)]

它的运行机制是这样的：

[x]生成一个列表的列表，它只有一个元素x

[x] * 3生成一个列表的列表，它有3个元素，[x, x, x]

zip(* [x] * 3)的意思就明确了，zip([1,2,3], [1,2,3],[1,2,3])

列题描述

1 输入一个字符串s，输入一个整数k,将字符串按长度k切割，并且子串中不能有相同的元素，输出该子串

2 样本输入

3 AABCAAADA

4 3   

5 样本输出

6 AB

7 CA

8 AD

 

解决办法

1 2 3 4

s, n = input(), int(input())  for part in zip(*[iter(s)] * n):     d = dict()     print(''.join([ d.setdefault(c, c) for c in part if c not in d ]))

关键点理解

1.zip(*[iter(S)]*N)

    iter(S):生成一个s的生成器

    [iter(S)]*N:相当于[iter(S),iter(S),iter(S)],这里的复制是浅复制

    

            >>> l = [1,2,3]

            >>> m = ([l]*3)

            >>> print(m)

            [[1, 2, 3], [1, 2, 3], [1, 2, 3]]

            >>> m[0][0] = 9

            >>> print(m)

            [[9, 2, 3], [9, 2, 3], [9, 2, 3]]   

    zip(*[iter(s),iter(s),iter(s)]]=zip(iter(s),iter(s),iter(s))

    由于是同一个生成器对象所以在你调用for循环的时候相当于调用next()方法，设x1=第一个iter(S)

 x2=第二个iter(s)，第三个。。。。，for的时候调用next(x1),假设输出1，而此时for x2的时候输出输出x1的下一个数，x3同理

 二：lambda匿名函数

　　

名函数操作：

l =[1,2,3,4]
list(map(lambda x: x**2, l))out[4]: [1, 4, 9, 16] 

同时操作两个 list(并行非多核运算)

 l =[1,2,3,4]
list(map(lambda x,y: x+y,l,l))out[5]: [2, 4, 6, 8] 

注：python3 和 python2 中map()的返回值不一样， python2 中直接返回列表，python需要加list()转换取值。

filter()函数——筛选函数

• 按照 function 函数的规则在列表 sequence 中筛选数据
• 用法：filter(function, sequence)

筛选 list 中符合条件的值

l =[1,2,3,4]
filter(lambda x: x>2, l)out[6]: [3, 4] 

filter() 与 map() 返回值不同

l =[1,2,3,4]map(lambda x: x>2, l)

out[8]: [false, false, true, true]

reduce()——求积累运算

• reduce函数功能是将 sequence 中数据，按照 function 函数操作，如将列表第一个数与第二个数进行 function 操作，得到的结果和列表中下一个数据进行 function 操作，一直循环下去…

• 用法reduce(function, sequence):

求积累和

l =[1, 2, 3, 4]
reduce(lambda x,y: x+y, l)out[10]: 10 

zip()打包函数

• zip()是 python 的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回 list 的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压）。

• 用法: zip(list,list)

zip()基本用法

l1 = [1, 2, 3, 4]
l2 = ['a', 'b', 'c', 'd']zip(l1,l2)
out[12]: [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

使用*逆过程

l1 = [1, 2, 3, 4]
l2 = ['a', 'b', 'c', 'd']
zip_l1_l2 = zip(l1,l2)zip(*zip_l1_l2)

out[17]: [(1, 2, 3, 4), ('a', 'b', 'c', 'd')]

zip 构造字典

l1 = [1, 2, 3, 4]
l2 = ['a', 'b', 'c', 'd']
zip_l1_l2 = zip(l1,l2)dict(zip_l1_l2)

out[18]: {1: 'a', 2: 'b', 3: 'c', 4: 'd'}