- 实际应用
# 1. 两个list的相加
a=[1,2,3]
b=[4,5,6]
现将list a与 list b按位相加，其结果为[5,7,9]
方法一：
c=[a[i]+b[i] for i in range(min(len(a),len(b)))]
方法二：【map()函数，zip()函数】
c=list(map(lambda x :x[0]+x[1] ,zip(a,b)))
方法三：
import numpy as np
c = np.array(a) + np.array(b)
# 2. 求True的最大值，false的最小值
tuple_list = [(True,11),(True,12),(False,22),(False,32),(True,52),(True,2),]
方法1：一不小心的神操作
res_max = max(tuple_list)
res_min = min(tuple_list)
方法2：
res = max(tuple_list) # (True, 52)
res = max(tuple_list,key=lambda x:~x[0]) # (False, 22)
res = max(tuple_list,key=lambda x:(~x[0],x[1])) # (False, 32)
方法3：
# new_start = max([i.get()[1] for i in result_dic.values() if i.get()[0]])
# new_end = min([i.get()[1] for i in result_dic.values() if not i.get()[0]])
-
高阶函数，接收函数作为参数，或者将函数作为返回值的函数是高阶函数；
-
5个带key内置函数
-
1.filter/map(function, iterable) --> 迭代器
-
2.sorted(iterable[, cmp[, key[, reverse]]]) --> list
-
3.min/max(iterable, *[, default=obj, key=func]) --> value
-
下面的两个不是：但是常用
-
enumerate(sequence, [start=0])
-
zip([iterable, ...])
-
-
这类函数总结
a = [1,2,3,1,1,1,3,3,3,3]
#1
print(max(a,key=a.count)) # a.count(3) = 5
#2 上面的等价于
l ={}
for i in a:
l[a.count(i)]=i
res_num = max(l)
res_id = l[res_num]
print(l)
print(res_num,res_id)
- max
#count函数先理解
a = [1,2,3,3,2,2,2,2]
print(a.count(2)) # 5
print(max(set(a),key=a.count)) #2
# max() 方法返回给定参数的最大值，参数可以为序列。
lis = [1,2,3,-4]
print(max(lis)) #返回lis列表中的最大值 # 3
print(max(lis,key=abs)) #key参数指向绝对值函数，返回的结果是-4
- min
#（2）min
# min() 方法返回给定参数的最小值，参数可以为序列。
lis = [-1,0,1,2]
print(min(lis)) #返回lis列表中的最小值 # -1
- fileter
'''
unittest源码中
'''
def getTestCaseNames(self, testCaseClass):
"""Return a sorted sequence of method names found within testCaseClass
"""
#这里定义filter函数
def shouldIncludeMethod(attrname):
if not attrname.startswith(self.testMethodPrefix):
return False
testFunc = getattr(testCaseClass, attrname)
if not callable(testFunc):
return False
fullName = f'%s.%s.%s' % (
testCaseClass.__module__, testCaseClass.__qualname__, attrname
)
return self.testNamePatterns is None or
any(fnmatchcase(fullName, pattern) for pattern in self.testNamePatterns)
#filter 使用方法
testFnNames = list(filter(shouldIncludeMethod, dir(testCaseClass)))
#是否排序
if self.sortTestMethodsUsing:
#testFnNames是列表，sort是python3里面的列表方法
#case的排序
testFnNames.sort(key=functools.cmp_to_key(self.sortTestMethodsUsing))
return testFnNames
# filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。
# 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回
# True 的元素放到新列表中。
# 语法格式：filter(function, iterable)
#实例1
def is_odd(x):
return x % 2 == 1
print(list(filter(is_odd,[1,2,3,4,5,6,7,8,9]))) #python3中不使用list强转数据类型的话，filter返回的是迭代器
'''结果：
[1, 3, 5, 7, 9]
'''
#实例2
s = 'jason lv'
iterator = filter(lambda x : x !='a',s)
s1 = ''
for i in iterator:
s1 += str(i)
print(s1)
'''结果：
json lv
'''
# 不是常用 20210727
# 字符串拼接
FirstName = 'f'
# LastName = None
LastName = 'l'
FullName = ', '.join(filter(None, (LastName, FirstName)))
print(FullName)
# f
# l, f
- map
# map() 会根据提供的函数对指定序列做映射。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回一个迭代器对象。
# 语法格式：map(function, iterable, ...)
#实例1
def pow2(x):
return x * x
lis = [1,2,3,4,5,6]
print(list(map(pow2,lis)))
'''结果：
[1, 4, 9, 16, 25, 36]
'''
#实例2
lis = [1,2,3,4,5,6]
print(list(map(lambda x : x *10 if x >3 else x / 2,lis)))
'''结果：
[0.5, 1.0, 1.5, 40, 50, 60]
'''
#碰到
iterm = ['1','2','3']
print(','.join(iterm))
# 上面等价于
iterm = [1,2,3]
print(','.join(map(str,iterm)))
'''
unittest源码中
'''
def loadTestsFromTestCase(self, testCaseClass):
"""Return a suite of all test cases contained in testCaseClass"""
if issubclass(testCaseClass, suite.TestSuite):
raise TypeError("Test cases should not be derived from "
"TestSuite. Maybe you meant to derive from "
"TestCase?")
testCaseNames = self.getTestCaseNames(testCaseClass)
if not testCaseNames and hasattr(testCaseClass, 'runTest'):
testCaseNames = ['runTest']
#map(function, iterable) 返回迭代器
loaded_suite = self.suiteClass(map(testCaseClass, testCaseNames))
return loaded_suite
'''
其他示例
'''
# 使用 lambda 匿名函数
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])
[1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
- sorted 注意不是Sort，Sort函数是list列表中的函数
- sort 与 sorted 区别：（注意sort 没有返回值的坑）
- sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
- list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
#（5）sorted
# Sort函数是list列表中的函数，而sorted可以对list或者iterator进行排序。
# 语法格式：sorted(iterable[, cmp[, key[, reverse]]])
# 参数说明：
# (1) cmp参数
# cmp接受一个函数，拿整形举例，形式为:
# def f(a, b):
# return a - b
#
# 如果排序的元素是其他类型的，如果a逻辑小于b，函数返回负数；a逻辑等于b，函数返回0；a逻辑大于b，函数返回正数就行了
# (2)key参数
# key也是接受一个函数，不同的是，这个函数只接受一个元素, 形式如下
# def f(a):
# return len(a)
#
# key接受的函数返回值，表示此元素的权值，sort将按照权值大小进行排序
#
# (3)reverse参数
# 接受False
# 或者True
# 表示是否逆序
# 语法格式：sorted(iterable[, cmp[, key[, reverse]]])
#实例1
lis = [3,2,1,4,5,6]
print(list(sorted(lis,reverse=True)))
'''结果
[6, 5, 4, 3, 2, 1]
'''
print(list(sorted(lis))) #默认不指定reverse参数时，顺序是正序
'''结果
[1, 2, 3, 4, 5, 6]
'''
#实例2
lis = ['adf ee','zcv','qwer','a s s w']
print(list(sorted(lis,key=len)))
'''结果：
['zcv', 'qwer', 'adf ee', 'a s s w']
'''
# robot源码
def __iter__(self):
print('##',self._keys)
print('##',sorted(self._keys))
return (self._keys[norm_key] for norm_key in sorted(self._keys))
'''打印
## {'d': 'd', 'b': 'b', 'c': 'C'}
## ['b', 'c', 'd'] 【注意返回的是列表】
'''