Python进阶学习日常笔记1

 python学习笔记分享

主要是关于一些数据结构不太常见的操作，具体都写在注释里面辣

需要有python语法基础，了解list，set，dict等数据结构的基本操作噢！

代码之前是写在notebook上的，所以有些地方会有省略的print

# 数据结构--元组拆包
# eg
p = (4, 5)
x, y = p
x
# 元组可以同时赋值给对应个数的变量
# 变量数不能多于元组含有元素数
# 同理，对列表，字符串等可以进行相同的操作

s = 'Hello'
a, b, c, d, e = s
print(e+d+c+b+a)

# 若只需要一部分，可以使用_进行占位操作
_, a, b, _, _ = s
a
# 注意，占位也是变量
# 可以使用任意名字进行占位操作
print(_)

# 如果想减少变量个数，需要利用*操作符
grades = [123, 99, 88, 77, 1000]
# 想丢弃第一个和最后一个不合理的分数, 并计算平均值
from numpy import average
def drop_first_last(grades):
  first, *middle, last = grades
  return average(middle)
drop_first_last(grades)

# collections库deque，保留有限的历史记录
from collections import deque
def search(lines, pattern, history=5):
  previous_lines = deque(maxlen=history)
  for line in lines:
    if pattern in line:
      yield line, previous_lines
    previous_lines.append(line)
# 实现简单的文本匹配，返回pattern所在行的最后history行

# deque使用示例
from collections import deque
q = deque() # 得到一个无限长的队列
q.append(1)
q.append([2, 3]) # 放一个列表，列表并不会被拆解
q.pop() # 弹出最右边一个
q.popleft() # 弹出左边一个
q = deque(maxlen=3)
q.append(1)
q.append(2)
q.append(3)
q.pop()
q.popleft()
q.appendleft(5) # 从左边放入元素
q

# 查询最大或最小的n个元素
# 利用heapq模块的nlargest，nsmallest
import heapq
nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]
print(heapq.nlargest(3, nums)) # Prints [42, 37, 23]
print(heapq.nsmallest(3, nums)) # Prints [-4, 1, 2]
# 对于更复杂的数据结构，可以加入lambda表达式
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
cheap
# 当只需要1个的时候，使用min，max更快
# 当需要接近集合大小时，推荐sorted
# heapq底层时进行堆排序，需要几个就排几次，每次取出第一个

# 利用heapq实现简单的优先队列
class PriorityQueue:
  def __init__(self):
    self._queue = []
    self._index = 0

  def push(self, item, priority):
    # 元组比大小先比第一个位置，相同则往后依次比较
    # 增添index的目的是防止出现优先级相同的元素导致比较失败（考虑item一般不可比）
    heapq.heappush(self._queue, (-priority, self._index, item))
    self._index += 1

  def pop(self):
    return heapq.heappop(self._queue)[-1]

# 字典实现一个键映射多个值
# 让值成为列表或集合（列表可以保持元素顺序，集合可以去掉重复元素）
d = {
    'a' : [1, 2, 3],
    'b' : [4, 5]

}
d['a'][2]

# collections 库中的defaultdict
from collections import defaultdict


d = defaultdict(list)
d['a'].append(1)
d['a'].append(10)
d

e = defaultdict(set)
# 集合没有append操作，而是add操作
e['a'].add(1)
e['a'].add(1)
# 添加了两次，但是e['a]={1}
e

# 字典排序
# 利用collections中的OrderedDict保持元素的插入顺序
# 对字典中元素求取最大最小值
prices = {
  'ACME': 45.23,
  'AAPL': 612.78,
  'IBM': 205.55,
  'HPQ': 37.20,
  'FB': 10.75
}
# 直接调用min是根据键的大小排序
min(prices)
# 调用prices.values()则会丢失键的信息
min(prices.values())
# 使用zip将键值对反转再进行min，max，sorted
min_price = min(zip(prices.values(), prices.keys()))
min_price
prices_sorted = sorted(zip(prices.values(), prices.keys()))
prices_sorted

# 查找两个字典的相同点
# 通过对两个字典进行集合操作！
# 考虑以下两个字典
a = {
  'x' : 1,
  'y' : 2,
  'z' : 3
}
b = {
  'w' : 10,
  'x' : 11,
  'y' : 2
}
# 找相同的键，则进行&操作（求交集）
a.keys() & b.keys()
# 找a有b没有，-（集合差运算）
a.keys() - b.keys()
# 当然可以同时对键值对运算
a.items() & b.items()
# a.values() & b.values()报错
# values不支持集合操作某种
# 程度上是因为值视图不能保证所有的值互不相同，这样会导致某些集合操作会出现问题
# 不过，如果你硬要在值上面执行这些集合操作的话，你可以先将值集合转换成 set

# 删除序列相同的元素并保持顺序
def remove(items):
  # 指定一个空的集合用来储存已经出现的元素
  # 由于集合的属性是可以去除重复元素的，所以可以一直add
  # 不直接返回集合的原因是这样会打乱元素顺序，不满足要求
  mark = set()
  ls = []
  for item in items:
    if item not in mark:
      ls.append(item)
    mark.add(item)
  # print(ls)
  return ls

a = [1, 5, 2, 1, 9, 1, 5, 10]
remove(a)

# 如果需要去除字典的重复元素？字典的items是不可以直接进行判断比较的
# 需要进行指定是看值还是看键
# 当然，除了用一个容器在函数里面装好，还可以用yield关键字
# 返回迭代器，这样可以对这个函数的返回值进行list，set等操作转换成指定容器
def dedupe(items, key=None):
  seen = set()
  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}]
list(dedupe(a, key=lambda d: (d['x'],d['y'])))

# 如果仅仅是去重而无关顺序的话
a = [1, 5, 2, 1, 9, 1, 5, 10]
# 只需要set一下就行
set(a)