预备知识：

python解包：

1. 将容器里面的元素逐个取出来（防杠精：此处描述并不严谨，因为容器中的元素并没有发生改变）放在其它地方，好比你老婆去菜市场买了一袋苹果回来分别发给家里的每个成员，这个过程就是解包。

#列表解包
>>> a, b, c = [1,2,3]
#元组解包
>>> a,b,c = (1,2,3)
#字符串解包
>>> a,b,c = "abc"
#字典解包：注意字典解包后，只会把字典的 key 取出来，value 则丢掉了
>>> a,b,c = {"a":1, "b":2, "c":3}  
>>> a
'a'
>>> b
'b'
>>> c
'c'

#特殊情况
#等号右边其实是一个元组对象 (1, 2)
>>> a, b = 1, 2
>>> a
1
>>> b
2
----------
>>> a = 1,
>>> a
(1,)
----------
>>> a = 1
>>> a
1
----------
#在 Python 中，交换两个变量非常方便，本质上也是自动解包过程。
>>> a, b = 1, 2
>>> a, b = b, a
>>> a
2
>>> b
1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

2. 若左边变量个数不等于右边变量个数，采用*解压（参见1.1，1.2节）
3. 函数调用时的解包操作：

>>> def func(a,b,c):
...     print(a,b,c)

#函数被调用的时候，使用星号 * 解包一个可迭代对象作为函数的参数。
>>> func(*[1,2,3])
1 2 3
>>> func(*(1,2,3))
1 2 3
>>> func(*"abc")
a b c
>>> func(*{"a":1,"b":2,"c":3})
a b c

#字典对象，可以使用两个星号，解包之后将作为关键字参数传递给函数，它会自动解包成关键字参数 key=value 的格式
>>> func(**{"a":1,"b":2,"c":3})  #相当于func(a=1,b=2,c=3)，注意字典的key必须是a,b,c
1 2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4. 利用解包，可以优雅的合并可迭代对象：

#合并列表
>>> list1 = [1,2,3]
>>> list2 = range(3,6)
>>> [*list1, *list2]
[1, 2, 3, 3, 4, 5]
#合并字典
>>> a = {"a":1, "b":2}
>>> b = {"c":3, "d":4}
>>> {**a, **b}
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
1
2
3
4
5
6
7
8
9
10

1.11:命名切片（使代码更清晰）

1. 内置的 slice() 函数创建了一个切片对象。所有使用切片的地方都可以使用切片对象。

######    0123456789012345678901234567890123456789012345678901234567890'
record = '....................100 .......513.25 ..........'
#直接使用切片
cost = int(record[20:23]) * float(record[31:37])
#命名切片
share = slice(20,23)
price = slice(31,37)
cost = int(record[share]) * float(record[price])
1
2
3
4
5
6
7
8

2. 可以分别调用切片对象的 a.start , a.stop , a.step 属性来获取更多的信息。

>>> a = slice(5, 50, 2)
>>> a.start
5
>>> a.stop
50
>>> a.step
2
>>>
1
2
3
4
5
6
7
8

3. indices(size) 方法可以把切片对象作用到新的序列上，这个方法返回一个三元组 (start, stop, step)。indices中的参数size相当于a.stop的位置，若大于之前的stop索引，则按之前的来，即按照原来的start,stop,step遍历新序列；若小于之前的stop索引，则按size来，即按照原来的start,step遍历新序列直至其结束

>>> a = slice(5, 50, 2)
>>> s = 'HelloWorld'
>>> a.indices(len(s))
(5, 10, 2)
#注意range(*a.indices(len(s)))这个操作
>>> for i in range(*a.indices(len(s))):
...     print(s[i])
...
W
r
d
>>>
1
2
3
4
5
6
7
8
9
10
11
12

1.12:序列种出现次数最多的元素

1. collections.Counter 类就是专门为这类问题而设计的，可以认为一个 Counter 对象就是一个字典，将元素映射到它出现的次数上。查找的key不存在时，不会报错

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
a = Counter(words)
#进行字典操作
print(a['why'])   #结果是0
print(a['eyes'])  #结果是8
1
2
3
4
5
6
7
8
9
10
11

2. 更新Counter的三种方式（推荐第三种）：

morewords = ['why','are','you','not','looking','in','my','eyes']
#更新方式1：
for i in morewords:
    a[i]+=1
#更新方式2：
b=Counter(morewords)
a=a+b
#更新方式3：
a.update(morewords)
1
2
3
4
5
6
7
8
9

3. most_common() 方法可直接查找出现次数前N的元素

a.most_common(1)  #输出结果为[('eyes', 9)]
a.most_common(3)  #输出结果为[('eyes', 9), ('the', 5), ('look', 4)]
1
2

1.13 通过某个关键字排序一个字典列表

1. 两种方式（使用 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}
]
#匿名函数
rows_by_fname = sorted(rows, key=lambda r: r['fname'])
rows_by_lfname = sorted(rows, key=lambda r: (r['lname'],r['fname']))
#operator 模块的 itemgetter 函数
rows_by_lfname = sorted(rows, key=itemgetter('fname'))
rows_by_lfname = sorted(rows, key=itemgetter('lname','fname'))
#sorted函数默认reverse=False，按升序排列
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 同样适用于 min() 和 max() 等函数

>>> min(rows, key=itemgetter('uid'))
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001}
>>> max(rows, key=itemgetter('uid'))
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
>>>
1
2
3
4
5

1.14 排序不支持原生比较的对象

1. 若想排序类型相同的对象，但是他们不支持原生的比较操作。方法与1.13基本相同，只是itemgetter()方法变成了attrgetter()，attrgetter() 函数通常会运行的快点

class User:
    def __init__(self, user_id):
        self.user_id = user_id

    def __repr__(self):
        return 'User({})'.format(self.user_id)
 
 users = [User(23), User(3), User(99)]
 #匿名函数
 sorted(users, key=lambda u: u.user_id)   #输出结果为[User(3), User(23), User(99)]
 #operator模块的attrgetter()方法
 from operator import attrgetter
sorted(users,key=attrgetter('user_id'))   #输出结果为[User(3), User(23), User(99)]
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 与itemgetter()方法相同，attrgetter()能同时允许多个字段进行比较，如果 User 实例还有一个 first_name 和 last_name 属性，那么可以向下面这样排序：

by_name = sorted(users, key=attrgetter('last_name', 'first_name'))
1

3. 这一小节用到的技术同样适用于像 min() 和 max() 之类的函数

>>> min(users, key=attrgetter('user_id'))
User(3)
>>> max(users, key=attrgetter('user_id'))
User(99)
>>>
1
2
3
4
5

1.15 通过某个字段将记录分组

1. 使用 defaultdict() 来构建一个多值字典

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 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'}
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. 首先需要按照指定的字段(这里就是 date )排序， 然后调用 itertools.groupby() 函数：

from operator import itemgetter
from itertools import groupby

# 注意sort和sorted的区别：
# sort应用在list上，会修改原列表
# sorted应用在可迭代对象上，生成一个新的可迭代对象，不会修改原数据结构
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'}
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

• groupby() 函数在每次迭代的时候，它会返回一个值（data）和一个迭代器对象（items），这个items由对应字段为相同的data组成
• 一个非常重要的准备步骤是要根据指定的字段将数据排序。 因为 groupby() 仅仅检查连续的元素，如果事先并没有排序完成的话，分组函数将得不到想要的结果。

1.16 过滤序列元素

1. 列表推导：

• 最简单的过滤序列元素的方法就是使用列表推导。

>>> mylist = [1, 4, -5, 10, -7, 2, 3, -1]
>>> [n for n in mylist if n > 0]
[1, 4, 10, 2, 3]
>>> [n for n in mylist if n < 0]
[-5, -7, -1]
>>>
1
2
3
4
5
6

• 列表推导还能在过滤的时候转换数据。

>>> mylist = [1, 4, -5, 10, -7, 2, 3, -1]
>>> import math
>>> [math.sqrt(n) for n in mylist if n > 0]
[1.0, 2.0, 3.1622776601683795, 1.4142135623730951, 1.7320508075688772]
>>>
1
2
3
4
5

• 过滤操作的一个变种就是将不符合条件的值用新的值代替，而不是丢弃它们。比如，在一列数据中你可能不仅想找到正数，而且还想将不是正数的数替换成0。

>>> clip_neg = [n if n > 0 else 0 for n in mylist]
>>> clip_neg
[1, 4, 0, 10, 0, 2, 3, 0]
>>> clip_pos = [n if n < 0 else 0 for n in mylist]
>>> clip_pos
[0, 0, -5, 0, -7, 0, 0, -1]
>>>
1
2
3
4
5
6
7

2. 列表生成：

• 使用列表推导的一个潜在缺陷就是如果输入非常大的时候会产生一个非常大的结果集，占用大量内存。 如果你对内存比较敏感，那么你可以使用生成器表达式迭代产生过滤的元素。

>>> pos = (n for n in mylist if n > 0)
>>> pos
<generator object <genexpr> at 0x1006a0eb0>
>>> for x in pos:
... print(x)
...
1
4
10
2
3
>>>
1
2
3
4
5
6
7
8
9
10
11
12

3. filter() 函数：

• filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
• 该函数接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

values = ['1', '2', '-3', '-', '4', 'N/A', '5']
def is_int(val):
    try:
        x = int(val)
        return True
    except ValueError:
        return False
ivals = list(filter(is_int, values))
print(ivals)
# Outputs ['1', '2', '-3', '4', '5']
1
2
3
4
5
6
7
8
9
10

4. itertools.compress()：类似pandas的布尔索引

• 以一个 iterable 对象和一个相对应的 Boolean 选择器序列作为输入参数。 然后输出 iterable 对象中对应选择器为 True 的元素。 当你需要用另外一个相关联的序列来过滤某个序列的时候，这个函数是非常有用的。
• 现在你想将那些对应 count 值大于5的地址全部输出，那么你可以这样做：

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]
>>> more5
[False, False, True, False, False, True, True, False]
>>> list(compress(addresses, more5))
['5800 E 58TH', '1060 W ADDISON', '4801 N BROADWAY']
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 和 filter() 函数类似， compress() 也是返回的一个迭代器。因此，如果你需要得到一个列表， 那么你需要使用 list() 来将结果转换为列表类型。

1.17 从字典中提取子集

1. 字典推导：

prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}

# Make a dictionary of all prices over 200
p1 = {key: value for key, value in prices.items() if value > 200}

# Make a dictionary of tech stocks
tech_names = {'AAPL', 'IBM', 'HPQ', 'MSFT'}
p2 = {key: value for key, value in prices.items() if key in tech_names}
#p2也可以通过这种方式生成，但是这种方式运行速度没有第一种快：
tech_names = { 'AAPL', 'IBM', 'HPQ', 'MSFT' }
p2 = { key:prices[key] for key in prices.keys() & tech_names }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. 大多数情况下字典推导能做到的，通过创建一个元组序列然后把它传给 dict() 函数也能实现。

p1 = dict((key, value) for key, value in prices.items() if value > 200)
1

• 但是，字典推导方式表意更清晰，并且实际上也会运行的更快些

1.18 映射名称到序列元素

1. collections.namedtuple() 函数可以定义一个通过名称访问元素的元组（原来的元组只能通过下标索引访问）

>>> from collections import namedtuple
>>> Subscriber = namedtuple('Subscriber', ['addr', 'joined'])
>>> sub = Subscriber('jonesy@example.com', '2012-10-19')
>>> sub
Subscriber(addr='jonesy@example.com', joined='2012-10-19')
>>> sub.addr
'jonesy@example.com'
>>> sub.joined
'2012-10-19'

#可对普通元组进行的操作对namedtuple一样使用
>>> len(sub)
2
>>> addr, joined = sub
>>> addr
'jonesy@example.com'
>>> joined
'2012-10-19'
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 命名元组的一个主要用途是将你的代码从下标操作中解脱出来。

#普通元组:下标操作通常会让代码表意不清晰，并且非常依赖记录的结构。
def compute_cost(records):
    total = 0.0
    for rec in records:
        total += rec[1] * rec[2]
    return total

#namedtuple
from collections import namedtuple
Stock = namedtuple('Stock', ['name', 'shares', 'price'])
def compute_cost(records):
    total = 0.0
    for rec in records:
        s = Stock(*rec)
        total += s.shares * s.price
    return total
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. 命名元组另一个用途就是作为字典的替代，因为字典存储需要更多的内存空间。但是需要注意的是，不像字典那样，一个命名元组是不可更改的。

>>> s = Stock('ACME', 100, 123.45)
>>> s
Stock(name='ACME', shares=100, price=123.45)
>>> s.shares = 75
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: can't set attribute
>>>
1
2
3
4
5
6
7
8

4. 若真的需要改变属性的值，那么可以使用命名元组实例的 _replace() 方法， 它会创建一个全新的命名元组并将对应的字段用新的值取代。

>>> s = s._replace(shares=75)
>>> s
Stock(name='ACME', shares=75, price=123.45)
>>>
1
2
3
4

• _replace() 方法还有一个很有用的特性就是当你的命名元组拥有可选或者缺失字段时候， 它是一个非常方便的填充数据的方法。

from collections import namedtuple

Stock = namedtuple('Stock', ['name', 'shares', 'price', 'date', 'time'])

# Create a prototype instance
stock_prototype = Stock('', 0, 0.0, None, None)

# Function to convert a dictionary to a Stock
def dict_to_stock(s):
    return stock_prototype._replace(**s)

>>> a = {'name': 'ACME', 'shares': 100, 'price': 123.45}
>>> dict_to_stock(a)
Stock(name='ACME', shares=100, price=123.45, date=None, time=None)
>>> b = {'name': 'ACME', 'shares': 100, 'price': 123.45, 'date': '12/17/2012'}
>>> dict_to_stock(b)
Stock(name='ACME', shares=100, price=123.45, date='12/17/2012', time=None)
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.19 转换并同时计算数据

1. 在数据序列上执行聚集函数（比如 sum() , min() , max() ）,有以下方法：

portfolio = [
    {'name':'GOOG', 'shares': 50},
    {'name':'YHOO', 'shares': 75},
    {'name':'AOL', 'shares': 20},
    {'name':'SCOX', 'shares': 65}
]

# 方法一：返回的是 {'name': 'AOL', 'shares': 20}
min_shares = min(portfolio, key=lambda s: s['shares'])
# 方法二：返回的是20
min_shares = min([s['shares'] for s in portfolio])
# 方法三：返回的是20
min_shares = min(s['shares'] for s in portfolio)
1
2
3
4
5
6
7
8
9
10
11
12
13

• 上述例子种，方法二显式的传递一个生成器表达式对象，而方法三是更加优雅的实现方式，省略了括号，使用一个生成器表达式参数。
• 方法二多一个步骤，先创建一个额外的列表。 对于小型列表可能没什么关系，但是如果元素数量非常大的时候， 它会创建一个巨大的仅仅被使用一次就被丢弃的临时数据结构。

2. 更多例子：

nums = [1, 2, 3, 4, 5]
s = sum(x * x for x in nums)

# Determine if any .py files exist in a directory
import os
files = os.listdir('dirname')
if any(name.endswith('.py') for name in files):
    print('There be python!')
else:
    print('Sorry, no python.')
    
# Output a tuple as CSV
s = ('ACME', 50, 123.45)
print(','.join(str(x) for x in s))

# Data reduction across fields of a data structure
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1.20 合并多个字典或映射

1. 方法一：使用 update() 方法将两个字典合并

>>> a = {'x': 1, 'z': 3 }
>>> b = {'y': 2, 'z': 4 }
>>> merged = dict(b)
>>> merged.update(a)
>>> merged['x']
1
>>> merged['y']
2
>>> merged['z']
3
1
2
3
4
5
6
7
8
9
10

这种方法行得通，但是它需要你创建一个完全不同的字典对象（或者是破坏现有字典结构）。 同时，如果原字典做了更新，这种改变不会反应到新的合并字典中去。

>>> a['x'] = 13
>>> merged['x']
1
1
2
3

2. 方法二：使用 collections 模块中的 ChainMap 类

from collections import ChainMap
c = ChainMap(a,b)
print(c['x']) # Outputs 1 (from a)
print(c['y']) # Outputs 2 (from b)
print(c['z']) # Outputs 3 (from a)
1
2
3
4
5

• 一个 ChainMap 接受多个字典并将它们在逻辑上变为一个字典。 然后，这些字典并不是真的合并在一起了， ChainMap 类只是在内部创建了一个容纳这些字典的列表 并重新定义了一些常见的字典操作来遍历这个列表。大部分字典操作都是可以正常使用的。

>>> len(c)
3
>>> list(c.keys())
['x', 'y', 'z']
>>> list(c.values())
[1, 2, 3]
>>>
1
2
3
4
5
6
7

• 如果出现重复键，那么第一次出现的映射值会被返回。 因此，例子程序中的 c[‘z’] 总是会返回字典 a 中对应的值，而不是 b 中对应的值。
• 对于字典的更新或删除操作总是影响的是列表中第一个字典。

>>> c['z'] = 10
>>> c['w'] = 40
>>> del c['x']
>>> a
{'w': 40, 'z': 10}
>>> del c['y']
Traceback (most recent call last):
...
KeyError: "Key not found in the first mapping: 'y'"
>>>
1
2
3
4
5
6
7
8
9
10

3. ChainMap相关函数：

• 可以认为前面的字典是child，后面的字典是parents

>>> values = ChainMap()
>>> values['x'] = 1
>>> # Add a new mapping
>>> values = values.new_child()
>>> values['x'] = 2
>>> # Add a new mapping
>>> values = values.new_child()
>>> values['x'] = 3
>>> values
ChainMap({'x': 3}, {'x': 2}, {'x': 1})
>>> values['x']
3
>>> # Discard last mapping
>>> values = values.parents
>>> values['x']
2
>>> # Discard last mapping
>>> values = values.parents
>>> values['x']
1
>>> values
ChainMap({'x': 1})
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23