第一部分:数据结构和算法
1.6、实现字典中的键映射多个值
一般对于字典来说，键和值都是一一对应的，如果需要实现实现一个键对应多个值，那么就需要借助列表或者其他的数据结构实现，但是问题也来了，列表在插入数据的时候，需要事先进行判断，这样就会产生额外的工作，如何避免在判断值得数据类型的前提下，实现一对多呢?
from collections import defaultdict
d = defaultdict(list) #设置字典的value的数据类型默认为list
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)
d = defaultdict(set) #设置字典的value的数据类型默认为set
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)
1.7、实现字典排序
默认字典是无序的，但是如果想要创建一个字典，在迭代或者序列化的时候可以保持元素插入的顺序，如何实现?
from collections import OrderedDict
def ordered_dict():
d = OrderedDict()
d['foo'] = 1
d['bar'] = 2
d['spam'] = 3
d['grok'] = 4
# Outputs "foo 1", "bar 2", "spam 3", "grok 4"
for key in d:
print(key, d[key])
ordered_dict()
比如如果需要编码为json的时候，精确控制编码之后的顺序，可以使用OrderedDict来创建这样一个字典;
注意:OrderedDict内部维护着一个插入顺序的双向链表，所以OrderedDict是普通字典的两倍，如果需要将大量的数据读入的这种字典中的时候，需要仔细衡量;
1.8、字典的运算
如何实现在字典中执行一些运算操作
下面是股票名和对应的价格
prices = { 'ACME': 45.23, 'AAPL': 612.78, 'IBM': 205.55, 'HPQ': 37.20, 'FB': 10.75 } min_price = min(zip(prices.values(), prices.keys())) #zip将两个列表的元素一一对应，为元祖 print(min_price) max_price = max(zip(prices.values(), prices.keys())) print(max_price)
#可以利用min和max函数中提供的key，获取最大值或者最小值对应的键的信息
print(min(prices, key=lambda k: prices[k]))
print(max(prices, key=lambda k: prices[k]))
注意:在上述中使用到了(值,键)对，但是，如果多个元素存在相同值的时候,键会决定返回的结果，如下:
prices = { 'AAA' : 45.23, 'ZZZ': 45.23 }
print(min(zip(prices.values(), prices.keys())))
print(max(zip(prices.values(), prices.keys())))
1.9、查找两个字典的相同点
字典就是一个键与值的映射关系表，keys()返回一个键的集合列表,其支持集合操作(并，交，差运算),但是values()因为值的元素可能存在重复，所以不支持集合操作,可以将values()转换为set，然后再进行集合操作;
items()返回的是元祖对象，支持集合操作;如下
a = {
'x' : 1,
'y' : 2,
'z' : 3
}
b = {
'w' : 10,
'x' : 11,
'y' : 2
}
print(a.keys() & b.keys())
print(a.keys() - b.keys())
print(a.items() & b.items())
c = {key:a[key] for key in a.keys() - {'z','w'}}
print(c)
结果如下:
{'x', 'y'}
{'z'}
{('y', 2)}
{'x': 1, 'y': 2}
1.10 删除序列相同元素并保持顺序
def dedupe(items):
seen = set()
for item in items:
if item not in seen:
yield item
seen.add(item)
a = [1, 5, 2, 1, 9, 1, 5, 10]
c = list(dedupe(a)) #生成器可以被循环打印元素，也可以被直接转换为list
print(dedupe(c))
print(c)
结果如下:
<generator object dedupe at 0x00000000030331B0>
[1, 5, 2, 9, 10]
1
5
2
9
10
如果上述序列都是hashabled的，那么可以直接通过set()或者生成器解决，但是如果序列不是hashabled的，那么就需要将序列转化为hashabled的，如下:
def dedupe(items, key=None):
seen = set() #此处的集合只用于中间判断元素是否有重合，使用yield可以让函数每次执行的时候，记得之前seen集合的元素
for item in items:
val = item if key is None else key(item)
if val not in seen:
yield item
seen.add(val)
a = [ {'x':1, 'y':2}, {'x':1, 'y':3}, {'x':1, 'y':2}, {'x':2, 'y':4}]
print(list(dedupe(a, key=lambda d: (d['x'],d['y'])))) #key用于将字典中的值转化为元祖
print(list(dedupe(a, key=lambda d: d['x'])))
对于一个序列，如果想要消除重复的元素,可以直接通过set()，就可以实现，但是这样会打乱元素的顺序，所以通常使用生产器的方式更为普遍;使用生成器的方式不仅在序列处理的时候可以使用,在文件处理的时候照样可以去掉重复的行;
上述的函数的key模仿了min、max、sorted等函数;
1.11、切片命名
items = [0, 1, 2, 3, 4, 5, 6]
a = slice(2, 4) #使用内置函数创建切片对象，是的代码更为可读
print(items[a])
items[a] = [10,11]
print(items)
del items[a]
print(items)
1.12、找到序列中出现最多的元素
Counter在几乎所有制表或者计算的场合非常有用
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)
top_three = word_counts.most_common(3) #找到频度出现最多的三个单词
print(top_three)
print(word_counts['not']) #单词not的个数
Counter可以非常容易的进行数学运算
morewords = ['why','are','you','not','looking','in','my','eyes']
a = Counter(words)
b = Counter(morewords)
c = a + b
print(c)
d = a - b
print(d)
结果为:
Counter({'eyes': 9, 'the': 5, 'look': 4, 'my': 4, 'into': 3, 'around': 2, 'not': 2, 'looking': 1, "you're": 1, 'under': 1, "don't": 1, 'are': 1, 'you': 1, 'why': 1, 'in': 1})
Counter({'eyes': 7, 'the': 5, 'look': 4, 'into': 3, 'around': 2, 'my': 2, 'under': 1, "you're": 1, "don't": 1})
1.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)
rows_by_lfname = sorted(rows, key=itemgetter('lname','fname')) #也支持多个key
print(rows_by_lfname)
当然，上述itemgetter函数也可以使用lamdba代替
rows_by_fname = sorted(rows, key=lambda r: r['fname'])
rows_by_lfname = sorted(rows, key=lambda r: (r['lname'],r['fname']))
最后，itemgetter函数同样也适用于min和max函数;
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)
rows_by_lfname = sorted(rows, key=itemgetter('lname','fname'))
print(rows_by_lfname)
1.14、排序不支持原生比较的对象
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))
sort_notcompare()
或者使用attrgetter实现
users = [User(23), User(3), User(99)]
from operator import attrgetter
print(sorted(users,key=attrgetter('user_id')))
1.15、通过某个字段将记录分组
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'},
]
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)
1.16、过滤序列元素
最常用的方式是使用列表推导的方式;但是使用列表推导的方式有可能会占用大量的内存,如果对内存数据比较敏感，可以使用生成器替代;
mylist = [1, 4, -5, 10, -7, 2, 3, -1] a = [n for n in mylist if n > 0] print(a) b= [n for n in mylist if n < 0] print(b)
生成器方法如下:
pos = (n for n in mylist if n > 0) #将列表变为元祖，就会变为生成器 print(pos) for n in pos: print(n)
还可以采用filter函数实现序列元素的过滤;
values = ['1', '2', '-3', '-', '4', 'N/A', '5']
def is_int(val):
try:
int(val)
return True
except ValueError:
return False
ivals = list(filter(is_int, values))
print(ivals)
过滤条件对于序列进行过滤，对于不符合条件的元素使用固定元素替换
clip_neg = [n if n > 0 else 0 for n in mylist]
print(clip_neg)
另外一个过滤工具是，可以根据一个序列的元素去过滤另外一个序列的元素;
addresses = [
'5412 N CLARK',
'5148 N CLARK',
'5800 E 58TH',
'2122 N CLARK'
'5645 N RAVENSWOOD',
'1060 W ADDISON',
'4801 N BROADWAY',
'1039 W GRANVILLE',
]
counts = [ 0, 3, 10, 4, 1, 7, 6, 1]
from itertools import compress
more5 = [n > 5 for n in counts] #返回布尔类型
print(more5)
print(list(compress(addresses,more5))) #compress函数返回的是一个迭代器，如果希望以列表的方式查看，就转换为列表的形式;
1.17、在字典中提取子集
最简单的方式就是使用字典推导
prices = {
'ACME': 45.23,
'AAPL': 612.78,
'IBM': 205.55,
'HPQ': 37.20,
'FB': 10.75
}
p1 = {key: value for key, value in prices.items() if value > 200}
print(p1)
tech_names = {'AAPL', 'IBM', 'HPQ', 'MSFT'}
p2 = {key: value for key, value in prices.items() if key in tech_names}
print(p2)
1.18、映射名称到序列元素
collections.namedtuple()
1.19、转换并同时计算
对于min()、max()、sum()等函数,需要先对元素进行过滤，然后再进行计算;
通过生成器表达式进行计算;
nums = [1, 2, 3, 4, 5] s = sum(x * x for x in nums) print(s) import os files=os.listdir('/') print(files) #files返回列表，元素为目录下面的文件名/目录名 if any(name.endswith('.py') for name in files): print('there have python file' ) s = ('ACME', 50, 123.45) print(','.join(str(x) for x in s))
portfolio = [
{'name':'GOOG', 'shares': 50},
{'name':'YHOO', 'shares': 75},
{'name':'AOL', 'shares': 20},
{'name':'SCOX', 'shares': 65}
]
min_shares = min(s['shares'] for s in portfolio)
print(min_shares)
min_shares = min(portfolio, key=lambda s: s['shares'])
print(min_shares)
也可以不使用生成器表达式计算
nums = [1, 2, 3, 4, 5] s = sum([x * x for x in nums]) #不使用生成器表达式的方式，会先创建一个列表
1.20、合并多个字典或者映射
需求:需要将多个字典或者映射逻辑上合并为一个之后，再执行一些其他的操作;
from collections import ChainMap a = {'x': 1, 'z': 3 } b = {'y': 2, 'z': 4 } d = {'a':1,'b':6} c = ChainMap(a,b,d) print(c) print(c['y']) print(c['z'])
ChainMap默认上不会改变原来的序列或者字典,这个字典不是真正意义上的字典;这和update不同;合并之后的字典支持大部分的字典操作;
需要注意的是:对于合并ChainMap生成的合并字典,删除和更新操作，只会影响第一个原来的字典;ChianMap使用原来的字典，但是自己不会新创建字典;
