python内置函数

一：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 def all(iterable):
2     for element in iterable:
3         if not element:
4             return False
5     return True

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

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 True if是否有任何字母字符。否则，打印 False 。在第三行中，打印 True if是否有任何数字。否则，打印 False 。在第四行中，print True if是否包含任何小写字符。否则，打印 False 。在第五行中，print True if是否有任何大写字符。否则，打印 False 。$

$实现代码$

 1 ----------------方法一-------------
 2 if __name__ == '__main__':
 3     s = input()
 4     print(any(c.isalnum for c in s))
 5     print(any(c.isalpha for c in s))
 6     print(any(c.isdigit for c in s))
 7     print(any(c.islower for c in s))
 8     print(any(c.isupper for c in s))
 9 -------------方法二--------------------
10 for test in ('isalnum', 'isalpha', 'isdigit', 'islower', 'isupper'):
11         any(eval("c." + test + "()") for c in s)

View Code

二：zip函数

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

1.zip函数使用

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生成器对象

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))），作为位置参数传递给对应函数（前提是对应函数支持不定个数的位置参数）

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

列题描述

解决办法

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同理

View Code

二：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'}