Python权威指南-数据结构和算法

# 为了对字典值执行计算操作，通常需要使用 zip() 函数先将键和值反转过来
prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}

min_price = min(zip(prices.values(), prices.keys()))

print(min_price) # min_prise is (10.75, 'FB')

max_price = max(zip(prices.values(), prices.keys()))

print(max_price) # max_price is (612.78, 'AAPL')

# 类似的，可以使用 zip() 和 sorted() 函数来按值来排列字典数据

prices_sorted = sorted(zip(prices.values(), prices.keys()))

print(prices_sorted)

# prices_sorted is [(10.75, 'FB'), (37.2, 'HPQ'),
# (45.23, 'ACME'), (205.55, 'IBM'),
# (612.78, 'AAPL')]

######################################################

# 执行这些计算的时候，需要注意的是 zip() 函数创建的是一个只能访问一次的迭 代器。

prices_and_names = zip(prices.values(), prices.keys())
print(min(prices_and_names)) # OK   最小的价格和名字  (10.75, 'FB')
# print(max(prices_and_names))  这行就会报错，因为prices_and_names只能访问一次。

#############################################################
# 如果你在一个字典上执行普通的数学运算，你会发现它们仅仅作用于键，而不是值

print(min(prices)) # Returns 'AAPL'
print(max(prices))# Returns 'IBM'

print(min(prices.values())) # Returns 10.75
print(max(prices.values())) # Returns 612.78

# # 不幸的是，通常这个结果同样也不是你想要的。你可能还想要知道对应的键的信息
#
# # 你可以在 min() 和 max() 函数中提供 key 函数参数来获取最小值或最大值对应的 键的信息。比如：
#
print(min(prices, key=lambda k: prices[k])) # Returns 'FB
print(max(prices, key=lambda k: prices[k])) # Returns 'AAPL'

###################################################################
# 需要注意的是在计算操作中使用到了 (值，键) 对。当多个实体拥有相同的值的时 候，键会决定返回结果。
# 比如，在执行 min() 和 max() 操作的时候，如果恰巧最小或 最大值有重复的，那么拥有最小或最大键的实体会返回：

prices = { 'AAA' : 45.23, 'ZZZ': 45.23 }
print(min(zip(prices.values(), prices.keys())))   # (45.23, 'AAA')

print(max(zip(prices.values(), prices.keys())))  #(45.23, 'ZZZ')

# 如果你想基于单个字段、属性或者某个更大的数据结构来消除重复元素
c = list(dedupe(a, key=lambda d: d['x']))

print(c)

# 如果你仅仅就是想消除重复元素，通常可以简单的构造一个集合，不能保证顺序

d = [1, 5, 2, 1, 9, 1, 5, 10]
print(set(d))

###################################
# 过滤工具就是itertools.compress() ，它以一个 iterable 对象和一个相对应的 Boolean 选择器序列作为输入参数。
# 然后输出 iterable 对象中 对应选择器为 True 的元素

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]

# 现在你想将那些对应 count 值大于 5 的地址全部输出

from itertools import compress

more5 = [n > 5 for n in counts]
print(more5)  #[False, False, True, False, False, True, True, False]

print(list(compress(addresses, more5)))  #['5800 E 58TH', '4801 N BROADWAY', '1039 W GRANVILLE']

# 这里的关键点在于先创建一个 Boolean 序列，指示哪些元素复合条件。
# 然后 compress() 函数根据这个序列去选择输出对应位置为 True 的元素

# 你的程序已经出现一大堆已无法直视的硬编码切片下标，然后你想清理下代码

# 假定你有一段代码要从一个记录字符串中几个固定位置提取出特定的数据字段

# 通常一个切片操作要提供三个参数 [start_index:  stop_index:  step]
# start_index是切片的起始位置
# stop_index是切片的结束位置（不包括）
# step可以不提供，默认值是1，步长值不能为0，不然会报错ValueError。

# 当 step 是负数时，以[start_index]元素位置开始，
# step做为步长到[stop_index]元素位置（不包括）为止，从右向左截取，

# start_index和stop_index不论是正数还是负数索引还是混用都可以，
# 但是要保证 list[stop_index]元素的【逻辑】位置
# 必须在list[start_index]元素的【逻辑】位置左边，否则取不出元素。

# 另外start_index和stop_index都是可以省略的，
# 比如这样的形式 [:], 被省略的默认由其对应左右边界起始元素开始截取。

# 切片;[0:3]  索引0开始取，直到索引3为止，但不包括索引3
#[-3:]获取列表的后3个元素，[:] ，[0:]获取所有元素

#指定增长步长  [0:101:10]   从索引0 到索引101，没间隔10个索引取出一个值。10为步长

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

print(cost)

# 命名切片，你避免了大量无法理解的硬编码下标，使得你的代码更加清晰可读

SHARES = slice(20, 23)
PRICE = slice(31, 37)
cost = int(record[SHARES]) * float(record[PRICE])

a = slice(5, 50, 2)

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

# 如果你有一个切片对象 a，你可以分别调用它的 a.start , a.stop , a.step 属性来 获取更多的信息。
# 还能通过调用切片的 indices(size) 方法将它映射到一个确定大小的序 列上，这个方法返回一个三元组 (start, stop, step) ，
# 所有值都会被合适的缩小以 满足边界限制，从而使用的时候避免出现 IndexError 异常

s = 'HelloWorld'
print(a.indices(len(s)))
for i in range(*a.indices(len(s))):
    print(s[i])

alist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(alist[-1:1:-1])

print(alist[-5:])

print(alist[:5])

# 取奇数位置元素

print(alist[1::2])

# https://blog.csdn.net/xpresslink/article/details/77727507