python数组

Python内置包

1.array

array 模块就是数组,可以存放放一组相同类型的数字,array模块是python中实现的一种高效的数组存储类型。它和list相似，但是所有的数组成员必须是同一种类型，在创建数组的时候，就确定了数组的类型

类型代码	C类型	Python类型	最小大小(字节为单位)
‘b’	signed char	int	1
‘B’	unsigned char	int	1
‘u’	Py_UNICODE	UNICODE字符	2
‘h’	signed short	int	2
‘H’	unsigned shot	int	2
‘i’	signed int	int	2
‘I’	unsigned int	int	2
‘l’	signed long	int	4
‘L’	unsigned long	int	4
‘q’	signed long long	int	8
‘Q’	unsigned long long	int	8
‘f’	float	float	4
‘d’	double	float	8

2.collenctions.deque

可以利用Python的列表的append()和pop()来实现一个队列但是这样的时间复杂度就大了（删除列表的第一个元素或者是在第一个元素的前面添加一个元素，会牵扯到移动列表里的所有元素），于是可以使用Python内置的collentions.deque类（双向列表）

collentions.deque是一个线程安全、可以快速从两端添加或者删除元素的数据类型。而且如果想要有一个种数据类型来存放“最近的几个元素”，deque也是一个很好的选择。这是因为新建这个双向列表时可以指定这个列表的大小，如果元素已经满了，还可以从反向端删除过期的元素，然后从尾端添加新的元素。

In [26]: dq = deque(range(10) ,maxlen=10)  # 指定一个容量为10的双向队列，maxlen是一个可选的参数，指定了就无法修改了

In [27]: dq
Out[27]: deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [28]: dq.rotate(3)  # 队列旋转操作参数n，n>0从最右边的第n个元素移动到队列的左边，n<0从最左边的n个元素移动到右边

In [29]: dq
Out[29]: deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6])

In [30]: dq.rotate(-4)

In [31]: dq
Out[31]: deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])

In [32]: dq.append(-1)

In [33]: dq
Out[33]: deque([2, 3, 4, 5, 6, 7, 8, 9, 0, -1])

In [35]: dq.extend([11, 22,33])

In [36]: dq
Out[36]: deque([5, 6, 7, 8, 9, 0, -1, 11, 22, 33])

In [37]: dq.extendleft([10, 20, 30, 40])

In [38]: dq
Out[38]: deque([40, 30, 20, 10, 5, 6, 7, 8, 9, 0])

append和popleft()都是原子操作，也就是说deque可以在多线程程序中安全地当做先进先出的队列使用，而使用者不必担心资源锁的问题

线程的通信除了deque以外还可以通过

• queue

  提供了同步（线程安全）类Queue、LifoQueue、PriorityQueue，不同的线程可以利用这些数据类型来交换信息。这三个类都有一个共同的可选参数maxsize，它接收正整数作为输入值，来限制队列的大小。

• multiprocessing

  这个包里面实现了自己的Queue，它跟queue.Queue类似，是设计线程间通信使用的。还有一个专门管理人物使用的multiprocessing.JoinableQueue类型，可以让任务变得更方便。

• asyncio

  Queue、LifoQueue、PriorityQueue、JoinableQueue

• heapq

  和上面的三个模块不一样的没有提供队列，但是提供了heappush和heappop

3.bisect

import bisect
import sys


HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]

ROW_FMT = '{0:2d} @ {1:2d}    {2}{0:<2d}'


def demo(bisect_fn):
    for needle in reversed(NEEDLES):
        position = bisect_fn(HAYSTACK, needle)
        offset = position * '  |'
        print(ROW_FMT.format(needle, position, offset))


if __name__ == '__main__':

    if sys.argv[-1] == 'life':
        bisect_fn = bisect.bisect_left
    else:
        bisect_fn = bisect.bisect


print('DEMO:', bisect_fn.__name__)
print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK))
demo(bisect_fn)

python3 文件名 left/right

利用bisect来找到位置

import bisect
import random

Size = 7

random.seed(1729)

my_list = []
for i in range(Size):
    new_item = random.randrange(Size*2)
    bisect.insort(my_list, new_item)
    print('%2d ->' % new_item, my_list)

4.memoryview

memoryview.cast的概念根数模块相似，可以用不同的方式读取同一个内存数据，而且内容字节不会随意移动。和C语言中类型转换的概念差不多。memoryview.cast会把同一块内容内打包成一个全新的memoryview对象给你。

In [1]: import array
In [3]: num = array.array('h', [-2, -1, 0, 1, 2])

In [4]: memv = memoryview(num)

In [5]: len(memv)
Out[5]: 5

In [6]: memv[0]
Out[6]: -2

In [7]: memv_oct = memv.cast('B')

In [8]: memv_oct
Out[8]: <memory at 0x7fa33d39c100>

In [9]: memv_oct.tolist()
Out[9]: [254, 255, 255, 255, 0, 0, 1, 0, 2, 0]  # 两个数字表示一个数字
# 同一块的内存里面读取的值方式不一样
# 'h'有符号的两个字节
# 'B'无符号的一个字节

In [10]: memv_oct[5] = 4  # 把5位置的字节复制成4

In [11]: num
Out[11]: array('h', [-2, -1, 1024, 1, 2])  

4.Unicode

• name

In [2]: from unicodedata import name

In [3]: {chr(i) for i in range(32, 256) if "SIGN" in name(chr(i), "")}
Out[3]:
{'#', '=', '¬', '©', '¶', '°', '+', '×', '÷', '¥', '>', '¢', 'µ', '£', '§', '%', '¤', '$', '®', '<', '±'}

In [6]: chr(35)
Out[6]: '#'

In [7]: name("#")
Out[7]: 'NUMBER SIGN'  # unicode 的编码name里面的编码标识