数据结构与算法 (03)

继续来进行 pythonCookbook. 学习大佬代码使我快乐, 与其自己写, 还不如直接抄, 然后加上自己的注解, 这样才是最适合我的学习之道哇.

仰之弥高,钻之弥坚

老祖宗还是厉害呀, 要是我能认识到这种境界, 夫复何求呦.

序列元素去重并保持顺序

需求

在一个序列上, 保持元素顺序的前提下, 对相同元素值进行去重

方案

如果序列中的值都是 hashable 类型的, 那直接用 集合 set 或者 生成器 就轻松解决了.

def filter_dumplicate(items):
    """序列元素去重"""
    seen = set()
    for item in items:
        if item not in seen:
            # 所有的 yield item 组成 生成器对象
            yield item 
            seen.add(item)

# test            
a = [1, 5, 2, 1, 9, 1, 5, 10]
print(list(filter_dumplicate(a)))

[1, 5, 2, 9, 10]

我感觉, 这个大佬, 是不是搞得太复杂, 还是我 too simple ?

# 这样不更简单吗
ret = []
for i in a:
    if i not in ret:
        ret.append(i)
print(ret)

[1, 5, 2, 9, 10]

就去个重, 私以为不用那么麻烦的吧. 其实更多的是, 我们通常不用考虑其顺序, 就去重, 这样一来, 直接用集合, 一波带走.

print(set(a))  # 集合元素的顺序, 呃,,我也不清楚

{1, 2, 5, 9, 10}

这类写法, 针对元素是 hashable 的时候ok的, 但对于不可哈希, 如 dict 类型 的序列, 要去重元素的话, 也可以这样.

def dedupe(items, key=None):
    """字典元素去重"""
    seen = set()
    for item in items:
        # key 有值则为dict,取其值, else 是单序列值
        val = item if key is None else key(item)
        if val not in seen:
            yield item 
            seen.add(val)
    
# test 以后写函数, 优先用 yield 而不用 list 来不断 append 啦
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‘]))))

print(list(dedupe(a, key=lambda d: d[‘x‘])))

[{‘x‘: 1, ‘y‘: 2}, {‘x‘: 1, ‘y‘: 3}, {‘x‘: 2, ‘y‘: 4}]
[{‘x‘: 1, ‘y‘: 2}, {‘x‘: 2, ‘y‘: 4}]

这个把函数改为生成器, 确实优雅呀, 学到了, 以后, 优先考虑哦. 不要再傻傻地只会 append 啦. 基于此中方法, 再对某单个字段或者属性, 或者更复杂的 数据结构来去重, 也是ok的.

可以发现, 针对于序列的遍历, 生成器 yield 则会更加通用, 而非以前傻傻滴, 先定义个空 lst , 过程中不断 append 这样就造成浪费内存了, yield 返回就行啦, 最后再统一 处理即可. 生成器, 对于文件中, 消除重复行, 也是可以的, 套路都固定的.

with open(some_file, ‘r‘) as f:
    for line in dedupe(f):
        ....

命名切片

需求

清理一大堆, 已经无法直视的硬编码切片下标.

方案

假设我们有一个切片, 是一个字符串中固定的位置, 如字符串或文件等.

###### 0123456789012345678901234567890123456789012345678901234567890‘ record = ‘....................100 .......513.25 ..........‘ cost = int(record[20:23]) * float(record[31:37])
record = ‘....................100 .......513.25 ..........‘ cost = int(record[20:23]) * float(record[31:37])
cost = int(record[20:23]) * float(record[31:37])

如果这样写切片, 维护起来简直崩溃, 于是呢,应该而给切片进行命名呀.

shares = slice(20, 33)

即用内置的 slice() 函数 创建一个切片对象, 可以被用在, 任何允许使用的方法.

items = [0, 1, 2, 3, 4, 5, 6]

# 前闭后开
a = slice(2,4)

print(items[2:4])
print(items[a])

items[a] = [88,99]
print(items)

del items[a]
print(items)

[2, 3]
[2, 3]
[0, 1, 88, 99, 4, 5, 6]
[0, 1, 4, 5, 6]

对于一个切片对象a, 还可以调用其 a.start, a.stop 等属性获取更多信息.

print(a)
print(a.start)
print(a.stop)

slice(2, 4, None)
2
4
个人感觉这玩意儿, 也没什么用呀.

序列中出现最多的元素

需求

找出序列中, 出现最多次数的元素.

方案

我做数据工作, 就会经常做这类的事情, 但我从来没有用过内置工具, 都是, 以字典的方式来进行词频统计, 感觉也行.

内置的 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 

# 初始化Counter 对象, 将统计序列加进去
word_counts = Counter(words)
print(word_counts.most_common()) 
# 选出频率最高的3个词
print("--"*8)
top_three = word_counts.most_common(3)
print(top_three)

[(‘eyes‘, 8), (‘the‘, 5), (‘look‘, 4), (‘into‘, 3), (‘my‘, 3), (‘around‘, 2), (‘not‘, 1), ("don‘t", 1), ("you‘re", 1), (‘under‘, 1)]
----------------
[(‘eyes‘, 8), (‘the‘, 5), (‘look‘, 4)]

作为输入, Counter 对象可以接受任意, 可哈希元素构成的序列对象. 在底层的实现上, 一个 Counter 对象就是一个车字典, 将元素映射到它出现的次数上.

# Counter 对象, 其实就是字典, value 是频次
print(word_counts[‘eyes‘])
print(word_counts[‘not‘])

8
1

结论就是, 词频统计之类的, 可以优先考虑 Counter 对象, 当然, 我手动弄字典也可以呀, 我乐意, 又不难.

过滤序列元素

需求

过滤序列元素, 根据某些规则

方案

最为简单和我最喜欢用的是, 列表推导式.

my_list = [1, 4, -5, 10, 2, 3, -1]

# 过滤出 大于 0 的元素
print([i for i in my_list if i > 0])

# 小于0, 且是 "奇数"
print([i for i in my_list if i < 0 and i % 2 == 1])

[1, 4, 10, 2, 3]
[-5, -1]

用列表推导式的一个问题在于, 当输入很大, 则会得到一个大的结果集, 浪费内存, 解决方案就是用 迭代器呀.

#  生成器就节约内存了, 优先考虑
pos = (i for i in my_list if i > 0 and i % 2 == 0)
print(pos)

for i in pos:
    print(i)

<generator object <genexpr> at 0x00000217B924F938>
4
10
2

有时候, 过滤条件复杂, 就需要把过滤的规则给放到一个函数中啦, 然后将其放到内置的 filter() 函数中.

values = [‘1‘, ‘2‘, ‘-3‘, ‘-‘, ‘4‘, ‘N/A‘, ‘5‘]

def is_int(val):
    try:
        x = int(val)
        return True
    except ValueError:
        return False
    
# test
list(filter(is_int, values))

[‘1‘, ‘2‘, ‘-3‘, ‘4‘, ‘5‘]

我感觉这 filter 和 map 函数的用法是差不多的, 一个是过滤出, True 的, 一个是做映射, 映射到每个元素. 同时, filter() 函数创建了一个迭代器.

想想, 还是列表推导式, 更加爽一点哦, 比如, 在推导的时候, 还是可以做数据转换的.

lst = [1, 4, -5, 10, -9, 2, 3, -1]

import math
print([math.sqrt(i) for i in lst if i > 0])

[1.0, 2.0, 3.1622776601683795, 1.4142135623730951, 1.7320508075688772]

不仅仅可以过滤, 结合 if - else 还能实现赋值.

# RELU 函数
print([i if i > 0 else 0 for i in my_list])

[1, 4, 0, 10, 2, 3, 0]

小结

• 序列去重且有序, 用集合 set 和 生成器 yield, 优先考虑
• 切片对象, 可用 slice 函数来创建命名对象, 便于管理
• 序列统计, 如词频统计, 优先用 collectiions.Counter().most_common() 方法, 自己写也不难.
• 过滤序列, 用列表推导式和生成器(元组推导式), 复杂结合 filter 函数, 结合 [a if aaa else b for aaa in xxx ]