数据结构
函数式编程工具
对于列表来讲, 有三个内置函数非常有用: filter(), map(), 以及 reduce().
filter(function, sequence)返回 function(item)为 true 的子序列. 会尽量返回和 sequence 相同的类型).sequence 是 string 或者 tuple 时返回相同类型, 其他情况返回 list . 实例: 返回能被 3 或者 5 整除的序列:
- #!python
- >>> def f(x): return x % 3 == 0 or x % 5 == 0
- ...
- >>> list(filter(f, range(2, 25)))
- [3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]
map(function, sequence) 为每个元素调用 function(item), 并将返回值组成一个列表返回. 例如计算立方:
- #!python
- >>> def cube(x): return x*x*x
- ...
- >>> list(map(cube, range(1, 11)))
- [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
函数需要多个参数, 可以传入对应的序列. 如果参数和序列数不匹配, 则按最短长度来处理. 如果传入的序列长度不匹配, 则用 None 不全. 例如:
- #!python
- >>> seq = range(8)
- >>> def add(x, y): return x+y
- ...
- >>> list(map(add, seq, seq))
- [0, 2, 4, 6, 8, 10, 12, 14]
- >>> seq1 = range(8)
- >>> seq2 = range(10)
- >>> list(map(add, seq1, seq2))
- [0, 2, 4, 6, 8, 10, 12, 14]
- >>> list(map(add, seq1, seq, seq2))
- ---------------------------------------------------------------------------
- TypeError Traceback (most recent call last)
- <ipython-input-19-2ddf805a1583> in <module>()
- ----> 1 list(map(add, seq1, seq, seq2))
- TypeError: add() takes 2 positional arguments but 3 were given
reduce(function, sequence) 先以序列的前两个元素调用函数 function, 再以返回值和第三个参数调用, 以此类推. 比如计算 1 到 10 的整数之和:
- #!python
- >>> from functools import reduce
- >>> def add(x,y): return x+y
- ...
- >>> reduce(add, range(1, 11))
- 55
如果序列中只有一个元素, 就返回该元素, 如果序列是空的, 就报异常 TypeError:
- #!python
- >>> reduce(add, [])
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- TypeError: reduce() of empty sequence with no initial value
- >>> reduce(add, [3])
- 3
可以传入第三个参数作为默认值. 如果序列是空就返回默认值.
- #!python
- >>> def sum(seq):
- ... def add(x,y): return x+y
- ... return reduce(add, seq, 0)
- ...
- >>> sum(range(1, 11))
- 55
- >>> sum([])
- 0
不要像示例这样定义 sum(), 内置的 sum(sequence) 函数更好用.
del 语句
del 可基于索引而不是值来删除元素.:del 语句. 与 pop() 方法不同, 它不返回值. del 还可以从列表中删除区间或清空整个列表. 例如:
- #!python
- >>> a = [-1, 1, 66.25, 333, 333, 1234.5]
- >>> del a[0]
- >>> a
- [1, 66.25, 333, 333, 1234.5]
- >>> del a[2:4]
- >>> a
- [1, 66.25, 1234.5]
- >>> del a[:]
- >>> a
- []
del 也可以删除整个变量:
#!python>>> del a
此后再引用 a 会引发错误.
元组和序列
链表和字符串有很多通用的属性, 例如索引和切割操作. 它们都属于序列类型(参见 Sequence Types - str, unicode, list, tuple, bytearray, buffer, xrange ).Python 在进化时也可能会加入其它的序列类型.
元组由逗号分隔的值组成:
- #!python
- >>> t = 12345, 54321, 'hello!'
- >>> t[0]
- 12345
- >>> t
- (12345, 54321, 'hello!')
- >>> # Tuples may be nested:
- ... u = t, (1, 2, 3, 4, 5)
- >>> u
- ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
- >>> # Tuples are immutable:
- ... t[0] = 88888
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- TypeError: 'tuple' object does not support item assignment
- >>> # but they can contain mutable objects:
- ... v = ([1, 2, 3], [3, 2, 1])
- >>> v
- ([1, 2, 3], [3, 2, 1])
元组在输出时总是有括号的, 嵌套元组可以清晰展示. 在输入时可以没有括号, 清晰起见, 建议尽量添加括号. 不能给元组的的元素赋值, 但可以创建包含可变对象的元组, 比如列表.
元组是不可变的, 通常用于包含不同类型的元素, 并通过解包或索引访问(collections 模块中 namedtuple 中可以通过属性访问). 列表是可变的, 元素通常是相同的类型, 用于迭代.
空的括号可以创建空元组; 要创建一个单元素元组可以在值后面跟一个逗号单元素元组. 丑陋, 但是有效. 例如:
- #!python
- >>> empty = ()
- >>> singleton = 'hello', # <-- note trailing comma
- >>> len(empty)
- 0
- >>> len(singleton)
- 1
- >>> singleton
- ('hello',)
- >>> ('hello',)
- ('hello',)
语句 t = 12345, 54321, 'hello!' 是 元组打包 (tuple packing)的例子: 值 12345,54321 和'hello!' 被封装进元组. 其逆操作如下:
- #!python
- >>> x, y, z = t
等号右边可以是任何序列, 即序列解包. 序列解包要求左侧的变量数目与序列的元素个数相同.
集合
集合是无序不重复元素的集. 基本用法有关系测试和去重. 集合还支持 union(联合),intersection(交),difference(差)和 sysmmetric difference(对称差集)等数学运算.
大括号或 set()函数可以用来创建集合. 注意: 想要创建空集合只能使用 set() 而不是 {}.
- #!python
- >>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
- >>> fruit = set(basket) # create a set without duplicates
- >>> fruit
- set(['orange', 'pear', 'apple', 'banana'])
- >>> 'orange' in fruit # fast membership testing
- True
- >>> 'crabgrass' in fruit
- False
- >>> # Demonstrate set operations on unique letters from two words
- ...
- >>> a = set('abracadabra')
- >>> b = set('alacazam')
- >>> a # unique letters in a
- set(['a', 'r', 'b', 'c', 'd'])
- >>> a - b # letters in a but not in b
- set(['r', 'd', 'b'])
- >>> a | b # letters in either a or b
- set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
- >>> a & b # letters in both a and b
- set(['a', 'c'])
- >>> a ^ b # letters in a or b but not both
- set(['r', 'd', 'b', 'm', 'z', 'l'])
类似列表推导式, 集合也可以使用推导式:
- #!python
- >>> a = {
- x for x in 'abracadabra' if x not in 'abc'
- }
- >>> a
- {
- 'r', 'd'
- }
字典
字典 (参见 Mapping Types - dict ). 字典在一些语言中称为联合内存 (associative memories) 或联合数组 (associative arrays). 字典以 key 为索引, key 可以是任意不可变类型, 通常为字符串或数值.
可以把字典看做无序的键: 值对 (key:value 对)集合.{}创建空的字典. key:value 的格式, 以逗号分割.
字典的主要操作是依据 key 来读写值. 用 del 可以删除 key:value 对. 读不存在的 key 取值会导致错误.
keys() 返回字典中所有关键字组成的无序列表. 使用 in 可以判断成员关系.
这里是使用字典的一个小示例:
- #!python
- >>> tel = {
- 'jack': 4098, 'sape': 4139
- }
- >>> tel['guido'] = 4127
- >>> tel
- {
- 'sape': 4139, 'guido': 4127, 'jack': 4098
- }
- >>> tel['jack']
- 4098
- >>> del tel['sape']
- >>> tel['irv'] = 4127
- >>> tel
- {
- 'guido': 4127, 'irv': 4127, 'jack': 4098
- }
- >>> tel.keys()
- ['guido', 'irv', 'jack']
- >>> 'guido' in tel
- True
dict() 构造函数可以直接从 key-value 序列中创建字典:
- #!python
- >>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
- {
- 'sape': 4139, 'jack': 4098, 'guido': 4127
- }
字典推导式可以从任意的键值表达式中创建字典:
- #!python
- >>> {
- x: x**2 for x in (2, 4, 6)
- }
- {
- 2: 4, 4: 16, 6: 36
- }
如果关键字都是简单的字符串, 可通过关键字参数指定 key-value 对:
- >>> dict(sape=4139, guido=4127, jack=4098)
- {
- 'sape': 4139, 'jack': 4098, 'guido': 4127
- }
序列和其它类型比较
序列对象可以与相同类型的其它对象比较. 比较基于字典序: 首先比较前两个元素, 如果不同, 就决定了比较的结果; 如果相同, 就比较后两个元素, 依此类推, 直到有序列结束. 如果两个元素是同样类型的序列, 就递归比较. 如果两个序列的所有子项都相等则序列相等. 如果一个序列是另一个序列的初始子序列, 较短的序列就小于另一个. 字符串的字典序基于 ASCII.
- #!python
- (1, 2, 3) < (1, 2, 4)
- [1, 2, 3] < [1, 2, 4]
- 'ABC' < 'C' < 'Pascal' < 'Python'
- (1, 2, 3, 4) < (1, 2, 4)
- (1, 2) < (1, 2, -1)
- (1, 2, 3) == (1.0, 2.0, 3.0)
- (1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
注意可以比较不同类型的对象也是合法的. 比较结果是确定的但是比较随意: 基于类型名 (Python 未来版本中可能发生变化) 排序. 因此, 列表始终小于字符串, 字符串总是小于元组, 等等. 不同数值类型按照它们的值比较, 所以 0 等于 0.0, 等等.
参考资料
讨论 qq 群 144081101 591302926 567351477 钉钉免费群 21745728
本文最新版本地址
本文涉及的 python 测试开发库 https://github.com/china-testing/python-api-tesing 谢谢点赞!
本文相关海量书籍下载
本文源码地址
计算不同版本人脸识别框的重合面积
现有某图片, 版本 1 识别的坐标为:(60, 188, 260, 387), 版本 2 识别的坐标为(106, 291, 340, 530))). 格式为 left, top, right, buttom.
请计算: 公共的像素总数, 版本 1 的像素总数, 版本 2 的像素总数, 版本 1 的重合面积比例, 版本 2 的重合面积比例.
参考代码:
- #!/usr/bin/python3
- # -*- coding: utf-8 -*-
- # Author: xurongzhong#126.com wechat:pythontesting qq:37391319
- # 技术支持 钉钉群: 21745728(可以加钉钉 pythontesting 邀请加入)
- # qq 群: 144081101 591302926 567351477
- # CreateDate: 2018-6-07
- def get_area(pos):
- left, top, right, buttom = pos
- left = max(0, left)
- top = max(0, top)
- width = right - left
- height = buttom - top
- return (width*height, left, top, right, buttom)
- def overlap(pos1, pos2):
- area1, left1, top1, right1, buttom1 = get_area(pos1)
- area2, left2, top2, right2, buttom2 = get_area(pos2)
- left = max(left1, left2)
- top = max(top1, top2)
- left = max(0, left)
- top = max(0, top)
- right = min(right1, right2)
- buttom = min(buttom1, buttom2)
- if right <= left or buttom <= top:
- area = 0
- else:
- area = (right - left)*(buttom - top)
- return (area, area1, area2, float(area)/area1, float(area)/area2)
- print(overlap((60, 188, 260, 387), (106, 291, 340, 530)))
详细代码地址
执行
- #!python
- $ python3 overlap.py
- (14784, 39800, 55926, 0.3714572864321608, 0.2643493187426242)
1 群
来源: http://www.jianshu.com/p/c186d94e732c