目录 |
| 目录 |
|
---|---|---|---|
数据结构和算法(一) | 1.将序列分解为单独的变量 2.解压可迭代对象赋值给多个变量 3.保留最后 N 个元素 4.查找最大或最小的 N 个元素 5.实现一个优先级队列 | 数据结构和算法(三) | 11.命名切片 12.序列中出现次数最多的元素 13.通过某个关键字排序一个字典列表 14.排序不支持原生比较的对象 15.通过某个字段将记录分组 |
数据结构和算法(二) | 6.字典中的键映射多个值 7.字典排序 8.字典的运算 9.查找两字典的相同点 10.删除序列相同元素并保持顺序 | 数据结构和算法(四) | 16.过滤序列元素 17.从字典中提取子集 18.映射名称到序列元素 19.转换并同时计算数据 20.合并多个字典或映射 |
11.命名切片
如果你的程序包含了大量无法直视的硬编码切片,并且你想清理一下代码。
假定你要从一个记录(比如文件或其他类似格式)中的某些固定位置提取字段:
###### 0123456789012345678901234567890123456789012345678901234567890'
record = '....................100 .......513.25 ..........'
cost = int(record[20:23]) * float(record[31:37])
与其那样写,为什么不像这样命名切片呢:
SHARES = slice(20, 23)
PRICE = slice(31, 37)
cost = int(record[SHARES]) * float(record[PRICE])
在这个版本中,你避免了使用大量难以理解的硬编码下标。这使得你的代码更加清晰可读。
一般来讲,代码中如果出现大量的硬编码下标会使得代码的可读性和可维护性大大降低。比如,如果你回过来看看一年前你写的代码,你会摸着脑袋想那时候自己到底想干嘛啊。这是一个很简单的解决方案,它让你更加清晰的表达代码的目的。
内置的 slice()
函数创建了一个切片对象。所有使用切片的地方都可以使用切片对象。比如:
>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]
如果你有一个切片对象 a
,你可以分别调用它的 a.start
,a.stop
,a.step
属性来获取更多的信息。比如:
>>> a = slice(5, 50, 2)
>>> a.start
5
>>> a.stop
50
>>> a.step
2
另外,你还可以通过调用切片的 indices(size)
方法将它映射到一个已知大小的序列上。这个方法返回一个三元组 (start, stop, step)
,所有的值都会被缩小,直到适合这个已知序列的边界为止。这样,使用的时就不会出现 IndexError
异常。比如:
>>> s = 'HelloWorld'
>>> a.indices(len(s))
(5, 10, 2)
>>> for i in range(*a.indices(len(s))):
... print(s[i])
...
W
r
d
12.序列中出现次数最多的元素
怎样找出一个序列中出现次数最多的元素呢?
collections.Counter
类就是专门为这类问题而设计的,它甚至有一个有用的 most_common()
方法直接给了你答案。
为了演示,先假设你有一个单词列表并且想找出哪个单词出现频率最高。你可以这样做:
words = [
'look', 'into', 'my', 'eyes', 'look', 'into', 'my', 'eyes',
'the', 'eyes', 'the', 'eyes', 'the', 'eyes', 'not', 'around', 'the',
'eyes', "don't", 'look', 'around', 'the', 'eyes', 'look', 'into',
'my', 'eyes', "you're", 'under'
]
from collections import Counter
word_counts = Counter(words)
# 出现频率最高的3个单词
top_three = word_counts.most_common(3)
print(top_three)
# Outputs [('eyes', 8), ('the', 5), ('look', 4)]
作为输入,Counter
对象可以接受任意的由可哈希(hashable
)元素构成的序列对象。在底层实现上,一个 Counter
对象就是一个字典,将元素映射到它出现的次数上。比如:
>>> word_counts['not']
1
>>> word_counts['eyes']
8
>>>
如果你想手动增加计数,可以简单的用加法:
>>> morewords = ['why','are','you','not','looking','in','my','eyes']
>>> for word in morewords:
... word_counts[word] += 1
...
>>> word_counts['eyes']
9
>>>
或者你可以使用 update()
方法:
>>> word_counts.update(morewords)
>>>
Counter
实例一个鲜为人知的特性是它们可以很容易的跟数学运算操作相结合。比如:
>>> a = Counter(words)
>>> b = Counter(morewords)
>>> a
Counter({'eyes': 8, 'the': 5, 'look': 4, 'into': 3, 'my': 3, 'around': 2, "you're": 1, "don't": 1, 'under': 1, 'not': 1})
>>> b
Counter({'eyes': 1, 'looking': 1, 'are': 1, 'in': 1, 'not': 1, 'you': 1, 'my': 1, 'why': 1})
>>> # Combine counts
>>> c = a + b
>>> c
Counter({'eyes': 9, 'the': 5, 'look': 4, 'my': 4, 'into': 3, 'not': 2, 'around': 2, "you're": 1, "don't": 1, 'in': 1, 'why': 1, 'looking': 1, 'are': 1, 'under': 1, 'you': 1})
>>> # Subtract counts
>>> d = a - b
>>> d
Counter({'eyes': 7, 'the': 5, 'look': 4, 'into': 3, 'my': 2, 'around': 2, "you're": 1, "don't": 1, 'under': 1})
>>>
毫无疑问,Counter
对象在几乎所有需要制表或者计数数据的场合是非常有用的工具。在解决这类问题的时候你应该优先选择它,而不是手动的利用字典去实现。
13.通过某个关键字排序一个字典列表
你有一个字典列表,你想根据某个或某几个字典字段来排序这个列表。
通过使用 operator
模块的 itemgetter
函数,可以非常容易的排序这样的数据结构。假设你从数据库中检索出来网站会员信息列表,并且以下列的数据结构返回:
rows = [
{'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},
{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001},
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
]
根据任意的字典字段来排序输入结果行是很容易实现的,代码示例:
from operator import itemgetter
rows_by_fname = sorted(rows, key=itemgetter('fname'))
rows_by_uid = sorted(rows, key=itemgetter('uid'))
print(rows_by_fname)
print(rows_by_uid)
代码的输出如下:
[{'fname': 'Big', 'uid': 1004, 'lname': 'Jones'},
{'fname': 'Brian', 'uid': 1003, 'lname': 'Jones'},
{'fname': 'David', 'uid': 1002, 'lname': 'Beazley'},
{'fname': 'John', 'uid': 1001, 'lname': 'Cleese'}]
[{'fname': 'John', 'uid': 1001, 'lname': 'Cleese'},
{'fname': 'David', 'uid': 1002, 'lname': 'Beazley'},
{'fname': 'Brian', 'uid': 1003, 'lname': 'Jones'},
{'fname': 'Big', 'uid': 1004, 'lname': 'Jones'}]
itemgetter()
函数也支持多个 keys
,比如下面的代码
rows_by_lfname = sorted(rows, key=itemgetter('lname','fname'))
print(rows_by_lfname)
会产生如下的输出:
[{'fname': 'David', 'uid': 1002, 'lname': 'Beazley'},
{'fname': 'John', 'uid': 1001, 'lname': 'Cleese'},
{'fname': 'Big', 'uid': 1004, 'lname': 'Jones'},
{'fname': 'Brian', 'uid': 1003, 'lname': 'Jones'}]
在上面例子中,rows
被传递给接受一个关键字参数的 sorted()
内置函数。这个参数是 callable
类型,并且从 rows
中接受一个单一元素,然后返回被用来排序的值。itemgetter()
函数就是负责创建这个 callable
对象的。
operator.itemgetter()
函数有一个被 rows
中的记录用来查找值的索引参数。可以是一个字典键名称,一个整形值或者任何能够传入一个对象的 __getitem__()
方法的值。 如果你传入多个索引参数给 itemgetter()
,它生成的 callable
对象会返回一个包含所有元素值的元组, 并且 sorted()
函数会根据这个元组中元素顺序去排序。 但你想要同时在几个字段上面进行排序(比如通过姓和名来排序,也就是例子中的那样)的时候这种方法是很有用的。
itemgetter()
有时候也可以用 lambda
表达式代替,比如:
rows_by_fname = sorted(rows, key=lambda r: r['fname'])
rows_by_lfname = sorted(rows, key=lambda r: (r['lname'],r['fname']))
这种方案也不错。但是,使用 itemgetter()
方式会运行的稍微快点。因此,如果你对性能要求比较高的话就使用 itemgetter()
方式。
最后,不要忘了这节中展示的技术也同样适用于 min()
和 max()
等函数。比如:
>>> min(rows, key=itemgetter('uid'))
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001}
>>> max(rows, key=itemgetter('uid'))
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
>>>
14.排序不支持原生比较的对象
你想排序类型相同的对象,但是他们不支持原生的比较操作。
内置的 sorted()
函数有一个关键字参数 key
,可以传入一个 callable
对象给它,这个 callable
对象对每个传入的对象返回一个值,这个值会被 sorted
用来排序这些对象。比如,如果你在应用程序里面有一个 User
实例序列,并且你希望通过他们的 user_id
属性进行排序,你可以提供一个以 User
实例作为输入并输出对应 user_id
值的 callable
对象。比如:
class User:
def __init__(self, user_id):
self.user_id = user_id
def __repr__(self):
return 'User({})'.format(self.user_id)
def sort_notcompare():
users = [User(23), User(3), User(99)]
print(users)
print(sorted(users, key=lambda u: u.user_id))
另外一种方式是使用 operator.attrgetter()
来代替 lambda
函数:
>>> from operator import attrgetter
>>> sorted(users, key=attrgetter('user_id'))
[User(3), User(23), User(99)]
>>>
选择使用 lambda
函数或者是 attrgetter()
可能取决于个人喜好。但是,attrgetter()
函数通常会运行的快点,并且还能同时允许多个字段进行比较。这个跟 operator.itemgetter()
函数作用于字典类型很类似。例如,如果 User
实例还有一个 first_name
和 last_name
属性,那么可以向下面这样排序:
by_name = sorted(users, key=attrgetter('last_name', 'first_name'))
同样需要注意的是,这一小节用到的技术同样适用于像 min()
和 max()
之类的函数。比如:
>>> min(users, key=attrgetter('user_id'))
User(3)
>>> max(users, key=attrgetter('user_id'))
User(99)
>>>
15.通过某个字段将记录分组
你有一个字典或者实例的序列,然后你想根据某个特定的字段比如 date
来分组迭代访问。
itertools.groupby()
函数对于这样的数据分组操作非常实用。为了演示,假设你已经有了下列的字典列表:
rows = [
{'address': '5412 N CLARK', 'date': '07/01/2012'},
{'address': '5148 N CLARK', 'date': '07/04/2012'},
{'address': '5800 E 58TH', 'date': '07/02/2012'},
{'address': '2122 N CLARK', 'date': '07/03/2012'},
{'address': '5645 N RAVENSWOOD', 'date': '07/02/2012'},
{'address': '1060 W ADDISON', 'date': '07/02/2012'},
{'address': '4801 N BROADWAY', 'date': '07/01/2012'},
{'address': '1039 W GRANVILLE', 'date': '07/04/2012'},
]
现在假设你想在按 date
分组后的数据块上进行迭代。为了这样做,你首先需要按照指定的字段(这里就是 date
)排序, 然后调用 itertools.groupby()
函数:
from operator import itemgetter
from itertools import groupby
# Sort by the desired field first
rows.sort(key=itemgetter('date'))
# Iterate in groups
for date, items in groupby(rows, key=itemgetter('date')):
print(date)
for i in items:
print(' ', i)
运行结果:
07/01/2012
{'date': '07/01/2012', 'address': '5412 N CLARK'}
{'date': '07/01/2012', 'address': '4801 N BROADWAY'}
07/02/2012
{'date': '07/02/2012', 'address': '5800 E 58TH'}
{'date': '07/02/2012', 'address': '5645 N RAVENSWOOD'}
{'date': '07/02/2012', 'address': '1060 W ADDISON'}
07/03/2012
{'date': '07/03/2012', 'address': '2122 N CLARK'}
07/04/2012
{'date': '07/04/2012', 'address': '5148 N CLARK'}
{'date': '07/04/2012', 'address': '1039 W GRANVILLE'}
groupby()
函数扫描整个序列并且查找连续相同值(或者根据指定 key
函数返回值相同)的元素序列。在每次迭代的时候,它会返回一个值和一个迭代器对象,这个迭代器对象可以生成元素值全部等于上面那个值的组中所有对象。
一个非常重要的准备步骤是要根据指定的字段将数据排序。因为 groupby()
仅仅检查连续的元素,如果事先并没有排序完成的话,分组函数将得不到想要的结果。
如果你仅仅只是想根据 date
字段将数据分组到一个大的数据结构中去,并且允许随机访问, 那么你最好使用 defaultdict()
来构建一个多值字典。比如:
from collections import defaultdict
rows_by_date = defaultdict(list)
for row in rows:
rows_by_date[row['date']].append(row)
这样的话你可以很轻松的就能对每个指定日期访问对应的记录:
>>> for r in rows_by_date['07/01/2012']:
... print(r)
...
{'date': '07/01/2012', 'address': '5412 N CLARK'}
{'date': '07/01/2012', 'address': '4801 N BROADWAY'}
>>>
在上面这个例子中,我们没有必要先将记录排序。因此,如果对内存占用不是很关心,这种方式会比先排序然后再通过 groupby()
函数迭代的方式运行得快一些。