python tricks（二）
python中常见数据结构
字典、映射和散列表
dict-首选字典实现
dict是python核心内容中的字典实现，其中键的顺序为无序。在python中可以通过直接输入{}大括号语法糖创建字典，要注意的是大括号也可用来创建集合，区别在于大括号中中是否含有键值对。
book = {
"a" = 1,
"b" = 2,
}
squares = {x: x * x for x in range(10)}
可作为字典键的数据必须为可散列的，如数字、字符串等。
dict经过python高度优化，一般首选dict实现字典。
有序字典
collections.OrderedDict可实现有序字典，他对键的插入顺序作记录。
import collections
a = collections.OrderedDict(one = 1, two = 2)
a["three"] = 3
>>>a
OrderedDict([("one", 1), ("two", 2), ("three", 3)]) #有很好的repr实现
有默认缺失值的字典
collections.defaultdict接受一个可调用对象，当查找键失败时，就创建此键并通过可调用对象创建对应的值。
import collections
a = collections.defaultdict(list)
a["one"] = 1
a["two"].append(2)
print(a)
>defaultdict(<class 'list'>, {'one': 1, 'two': [2]})
搜索多个字典
collections.ChainMap将多个字典连接在一起，搜索时从左到右按序搜索每个字典。对ChainMap进行插入、更新和删除只会对第一个字典生效。
import collections
a = {"one": 1}
b = {"two": 2}
c = collections.ChainMap(a, b)
print(c)
>ChainMap({'one': 1}, {'two': 2})
只读字典
types.MappingProxyType用来创建只读字典。主要用来返回一个原字典内容的视图，同时禁止对此视图进行修改，但是原字典的修改会反应到此代理上。
from types import MappingProxyType
a = {"one": 1}
b = MappingProxyType(a)
b["one"] = 2
>TypeError: 'mappingproxy' object does not support item assignment
数组
列表-动态可变数组
列表是python核心语言的部分，可以存储不同类型的数据。
元组-不可变数组
元组在创建后不可修改，可以存储不同类型数据。
array.array-类型数组
array.array最大的特点是只能存储一种数据类型。
import array
a = array.array("i", (1, 2, 3 ))
b = array.array("f", (1., 2., 3. ))
str-不可变字符数组
str将文本存储为不可变的Unicode字符序列。str可解包到列表形成可变字符序列。
a = "abc"
print(a[1])
b = list(a)
b[1] = "d"
print(b[1])
>b
>d
bytes-单字节不可变数组
bytes限制每个对象为0-255（包含）的整数。
bytes的repr有自己的语法。
a = bytes((1, 2, 3))
bytearray-单字节可变数组
bytearray和bytes相比可以修改，bytearray可以转换为buyes，但操作较慢，复杂度O(n)。
b = bytearray((1, 2, 3))
bytes(b)
记录、结构体和纯数据对象
与数组相比，记录数据结构中的字段数目固定，每一个都有名称，类型也可以不同。
字典-简单数据对象
元组-不可变对象集合
元组只能通过整数索引来访问，因此使用元组一般尽可能减少字段。
自定义类-手动精细控制
存储在类上的字段是可变的，且可以任意添加字段，使用property装饰器能创建只读字段。
typing.NamedTuple
typing.NamedTuple是不可变的有名称的元组，它以类的形式建立，补足了元组只有整数索引的缺点。
from typing import NamedTuple
class a(NamedTuple):
name: str
num_legs: int
Kal = a("Kal", 4)
Kal
>a(name='Kal', num_legs=4)
sturct.Struct-序列化C结构体
用于在python值和C结构体之间转换。
from struct import Struct
myStruct = Struct("i?f")
data = myStruct.pack(23, False, 1.4)
Mystruct.unpack(data) #解包
types.SimpleNamespace
扩展版的字典，可以使用obj.key这样的点式语法。
from types import SimpleNamespace
a = SimpleNamespace(name = "a",
num = 4)
集合和多重集合
set-首选集合实现
用花括号直接创建，可以添加、删除元素，并、交、差、子集操作平均耗时O(n)。
frozenset-不可变集合
a = frozenset({1, 2, 3})
b = {a:1} #frozenset可作为字典的键
collections.Counter-多重集合
当要记录数据和数据出现的次数时，可以使用。
from collections import Counter
a = Counter()
loot = {"bread":2, "milk":3}
a.update(loot) #2个面包，3瓶牛奶
a
>Counter({'bread': 2, 'milk': 3})
调用len(a)返回的是唯一元素的个数，调用sum(a.values())返回元素总数。
栈
栈是LIFO（后进先出）数据结构，通常不允许随机访问包含的对象。
列表实现
使用append()方法执行入栈，pop()方法出栈。性能不如链表。
collections.deque
collections.deque实现了一个双端队列，同样使用append()，pop()方法。
queue.LifoQueue
实现了锁语义支持多个并发的生产者和消费者。使用put()，get()方法。
队列
FIFO（先进先出），想象成一个水管，数据从右到左流动。
列表-非常慢的队列
使用append()和pop(0)方法。需要时间O(n)。
collections.deque
使用append()，popleft()。
queue.Queue
实现了锁语义支持多个并发的生产者和消费者。使用put()，get()方法。
优先队列
优先队列是一个容器数据结构，使用具有全序关系的键，以便快速访问序列中的最值。
优先队列通常用于处理调度问题。
列表
添加元素时添加有全序关系的键值对（元组），使用sort方法手动维护。
q = []
q.append((2, "Alice"))
q.append((1, "Jack"))
q.sort(reverse = True)
heapq-基于列表的二叉堆
import heapq
q = []
heapq.heappush(q, (2, "Alice"))
heapq.heappush(q, (1, "Jack"))
while q:
next_item = heapq.heappop(q)
queue.PriorityQueue-提供锁语义的heapq
from queue import PriorityQueue
q = PriorityQueue()
q.put((2, "Alice"))
q.put((1, "Jack"))
while q:
next_item = q.get(q)
来源：CSDN
作者：conFstantine
链接：https://blog.csdn.net/qq_38349710/article/details/103744553