Python 内置模块数据类型 collections,collections.abc,array

最新推荐文章于 2024-06-19 10:12:28 发布

EdVzAs

最新推荐文章于 2024-06-19 10:12:28 发布

阅读量1.1k

点赞数 2

文章标签： python 枚举/enumerate 队列/queue 抽象基类数据类型

本文链接：https://blog.csdn.net/weixin_46131409/article/details/110954253

版权

Python 专栏收录该内容

135 篇文章 3 订阅

订阅专栏

一.collections模块

参考:https://www.jianshu.com/p/47f66ff4ab7b $\qquad$ https://www.cnblogs.com/dianel/p/10787693.html

1.功能:

该模块实现了用于特定目标的容器,以提供标准内建容器dict/list/set/tuple的替代选择
提供的每种容器都是1个类,包括:
  Counter:dict的子类,提供了可哈希对象的计数功能
  defaultdict:dict的子类,提供了1个工厂函数,为字典查询提供了默认值
  OrderedDict:dict的子类,保留了元素被添加的顺序
  namedtuple:tuple的子类,提供了1个工厂函数,为元组中的每个元素命名
  deque:类似list的容器类,实现了在两端快速添加(append)和弹出(pop)
  ChainMap:类似dict的容器类,将多个映射集合到1个视图里

2.Counter:

为dict的子类,主要用于对单词/字符出现的次数进行计数,可以使用dict类型数据的方法

#创建Counter对象:
<c>=collections.Counter([<obj>]):创建1个Counter对象
  #参数说明:
    obj:1个可迭代对象,如list/tuple/dict/str/键值对,不能为num
      #如果不指定,则创建1个空的Counter对象
      #如果obj不可哈希化,则其元素必须可哈希化,或其元素中的元素必须均可哈希化,以此类推
    c:返回Counter对象

#实例:
>>> import collections
>>> collections.Counter("hello world")
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
>>> collections.Counter("hello world hello hello 你".split(" "))
Counter({'hello': 3, 'world': 1, '你': 1})
>>> collections.Counter({"asa":1,3:"sa"})
Counter({'asa': 1, 3: 'sa'})
>>> collections.Counter([1,1,"33D","33",4.44])
Counter({1: 2, '33D': 1, '33': 1, 4.44: 1})
>>> cnt=collections.Counter()
>>> wordlist=["a","s","d","f"]
>>> for word in wordlist:
...     cnt[word]+=1
...
>>> print(cnt)
Counter({'a': 1, 's': 1, 'd': 1, 'f': 1})
>>> collections.Counter(cats=10,dogs=2)#注意:不要给键名加引号!
Counter({'cats': 10, 'dogs': 2})

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

索引:同dict,也是通过key取值

#实例:
>>> c1=collections.Counter("hello world")
>>> c1["h"]
1
>>> c2=collections.Counter("hello world hello".split(" "))
>>> c2["hello"]
2
>>> c2["ddd"]
0

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

删除键:del <c>[<key>]
  #参数说明:
    c:Counter对象
    key:指定要删除的键

#实例:
>>> c
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
>>> c['w']=0#注意:将某个键对应的值设为0不能删除该键
>>> c
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'r': 1, 'd': 1, 'w': 0})
>>> del c['w']
>>> del c['o']
>>> c
Counter({'l': 3, 'h': 1, 'e': 1, ' ': 1, 'r': 1, 'd': 1})

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

<c>.elements():返回1个迭代器,其中元素为Counter对象中的元素
  #如果有相同的元素,都会被列出,而不会只列出1次
  #列出的顺序是任意的

#实例:
>>> list(c1.elements())
['h', 'e', 'l', 'l', 'l', 'o', 'o', ' ', 'w', 'r', 'd']
>>> list(c2.elements())
['hello', 'hello', 'world']

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

<c>.most_common([<n>]):返回1个列表,提供n个出现频率最高的元素及其出现的次数
  #参数说明:
    n:指定列出出现频率最高的n个元素;默认为所有元素
      #如果设为None,效果和不指定时相同

#实例:
>>> c1.most_common()
[('l', 3), ('o', 2), ('h', 1), ('e', 1), (' ', 1), ('w', 1), ('r', 1), ('d', 1)]
>>> c1.most_common(3)
[('l', 3), ('o', 2), ('h', 1)]

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

<c>.update([<iterable-or-mapping>]):向Counter对象中添加元素
  #会直接修改c,而不是返回1个修改后的拷贝
  #参数说明:
    iterable:指定要增加的元素;为可迭代对象或映射对象

<c>.subtract([<iterable-or-mapping>]):从Counter对象中减去元素
  #会直接修改c,而不是返回1个修改后的拷贝
  #参数说明:
    iterable:指定要减去的元素;为可迭代对象或映射对象

#实例:
>>> c1.update(c2)
>>> c1
Counter({'l': 3, 'o': 2, 'hello': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1, 'world': 1})
>>> c1.subtract(c2)
>>> c1
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1, 'hello': 0, 'world': 0})
>>> c1.update([1,2])
>>> c1
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1, 1: 1, 2: 1, 'hello': 0, 'world': 0})

#上述2个方法分别等价于:
<c>+<iterable-or-mapping>和<c>-<iterable-or-mapping>

#实例:
>>> c1+c2
Counter({'l': 3, 'o': 2, 'hello': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1, 'world': 1, 1: 1, 2: 1})
>>> c1-c2
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1, 1: 1, 2: 1})

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

<c>.clear():清空Counter对象中的所有元素

#实例:
>>> c1.clear()
>>> c1
Counter()

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

#常见操作:
>>> c=collections.Counter(a=5,b=4,c=-3,d=2)
>>> c
Counter({'a': 5, 'b': 4, 'd': 2, 'c': -3})
>>> sum(c.values())#统计所有元素的总数
>>> list(c)#列出所有唯一的元素
['a', 'c', 'b', 'd']
>>> set(c)#转换为set
set(['a', 'c', 'b', 'd'])
>>> dict(c)#转换为常规的dict
{'a': 5, 'c': -3, 'b': 4, 'd': 2}
>>> c.items()#转换为(elem,cnt)对构成的列表
[('a', 5), ('c', -3), ('b', 4), ('d', 2)]
>>> c.most_common()[:-4:-1]#输出n个数目最小元素
[('c', -3), ('d', 2), ('b', 4)]
>>> c += Counter()#删除数目为0和为负的元素
>>> c
Counter({'a': 5, 'b': 4, 'd': 2})
>>> Counter(dict(c.items()))#从(elem,cnt)对构成的列表转换为counter
Counter({'a': 5, 'b': 4, 'd': 2})
>>> c.clear()#清空counter
>>> c
Counter()

3.defaultdict:

为dict的子类,基本和dict相同,但重写了missing(<key>)方法并增加了1个可写的对象变量default_factory,
用于为key提供1个默认值

#创建DefaultDict对象:
<dfd>=collections.defaultdict([<default_factory>]):创建1个defaultdict对象
  #参数说明:
    default_factory:指定默认值;为callable对象/None
      #如果不指定,就是None
    dfd:返回defaultdict对象

#实例:更详细的用法可参考2篇参考文章
>>> dfd=collections.defaultdict(list)#默认值是1个空列表
>>> dfd
defaultdict(<class 'list'>, {})
>>> dfd["a"]
[]
>>> dfd
defaultdict(<class 'list'>, {'a': []})
>>> s=[('yellow',1),('blue',2),('yellow',3),('blue',4),('red',5)]
>>> for k,v in s:
...     dfd[k].append(v)#在默认值(1个空列表)中添加元素
...
>>> dfd
defaultdict(<class 'list'>, {'a': [], 'yellow': [1, 3], 'blue': [2, 4], 'red': [5]})
>>> dfd=collections.defaultdict()
>>> dfd["a"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'a'
>>> dfd
defaultdict(None, {})
>>> for k,v in s:
...     dfd[k].append(v)
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyError: 'yellow'
>>> for k,v in s:
...     dfd[k]=v
...
>>> dfd
defaultdict(None, {'yellow': 3, 'blue': 4, 'red': 5})
>>> dfd=collections.defaultdict(int)
>>> dfd["a"]
0
>>> dfd
defaultdict(<class 'int'>, {'a': 0})

4.OrderedDict:

为dict的子类,其中的键有顺序(按添加的顺序)
  #如果给已有的键赋新值,该键原来的位置会被保留
  #支持普通dict的所有方法
  #如果插入新键,将加到最后

#创建OrderedDict对象:
<od>=collections.OrderedDict([map_obj]):创建1个OrderedDict对象
  #参数说明:
    map_obj:指定键值对;可为元组构成的列表/dict
    od:返回OrderedDict对象

#实例:
>>> import collections
>>> o=collections.OrderedDict()
>>> o["k1"]="v1"
>>> o["k2"]="v2"
>>> o["k3"]="v3"
>>> o
OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
>>> o["k3"]="v33"
>>> o["k1"]="v11"
>>> o["b"]="z"
>>> o
OrderedDict([('k1', 'v11'), ('k2', 'v2'), ('k3', 'v33'), ('b', 'z')])
>>> collections.OrderedDict({"k1":"v1","k2":"v2","k3":"v3"})
OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
>>> collections.OrderedDict([(1,2),(3,4)])
OrderedDict([(1, 2), (3, 4)])

5.namedtuple:

为tuple的子类,会给元组中的每个位置命名,这意味着代码可读性更强;namedtuple可以在任何普通tuple使用的地
方使用，并且可通过名称来获取字段信息而不仅通过索引
  #支持普通tuple的所有方法

#创建namedtuple对象:
<nt_class>=collections.namedtuple(["<class_name>","<pn1>","<pn2>"...]):创建1个namedtuple类
  #该命令先创建1个namedtuple类,之后再通过返回的类创建namedtuple对象
  #参数说明:
    class_name:返回该namedtuple类的类名;为str
    pn1,pn2...:指定各个位置的名称(按顺序);为str
    nt_class:返回该namedtuple类
      #可以和class_name不同

<nt>=<nt_class>(<v1>,<v2>...):创建namedtuple对象
  #参数说明:
    v1,v2...:namedtuple对象中的值
    nt:返回namedtuple对象

#实例:
>>> zeta=collections.namedtuple('Point',["x","y"])
>>> z1=zeta(1,2)
>>> z1[0]
1
>>> z1.x
1

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

<nt>=<nt_class>._make(<itrbl>):从已有的可迭代对象创建1个namedtuple对象
  #参数说明:
    itrbl:用于创建namedtuple对象的可迭代对象

#实例:
>>> zeta._make([1,2])
Point(x=1, y=2)
>>> zeta._make({'y':2,'x':1})
Point(x='y', y='x')#注意:使用的是dict中的key
>>> zeta._make("as")
Point(x='a', y='s')

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

<od>=<nt>._asdict():将namedtuple转换成dict
  #参数说明:
    od:返回转换得到的dict对象

#实例:
>>> z1._asdict()
{'x': 1, 'y': 2}

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

<nnt>=<nt>._replace(<pn>=<v>):修改namedtuple对象指定位置的值
  #不会直接在<nt>上进行修改,而是返回修改后的namedtuple对象<nnt>
  #参数说明:
    pn:通过名称来指定要修改的字段
      #注意:不要加引号
    v:指定修改后的值
    nnt:返回修改后的namedtuple对象

#实例:
>>> z1._replace(x=111)
Point(x=111, y=2)
>>> z1
Point(x=1, y=2)

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

<nt_or_ntc>._fields:namedtuple对象/类中的所有字段名
  #是1个元组,其中的元素是各个字段名(为str)
  #参数说明:
    nt_or_ntc:指定namedtuple对象或namedtuple类

#实例:
>>> z1._fields
('x', 'y')
>>> zeta._fields
('x', 'y')

6.deque:

deque意为"double-end queue",是栈和队列的1种广义实现,支持线程安全,能以近似O(1)的性能在两端插入/删
除元素;而list主要在固定长度操作上进行优化,从而在pop(0)和insert(0,v)时(会改变列表长度)有O(n)的时间
复杂度

#创建deque对象:
<deq>=collections.deque([<obj>,<n>]):创建1个deque对象
  #参数说明:
    obj:1个可迭代对象
      #如果不指定,则创建1个空的Counter对象
      #如果obj不可哈希化,则其元素必须可哈希化,或其元素中的元素必须均可哈希化,以此类推
    n:指定最大长度(即.maxlen属性);默认无最大长度
    deq:返回deque对象

#实例:
>>> collections.deque("ssdfsd")
deque(['s', 's', 'd', 'f', 's', 'd'])
#将按元素在<obj>中的顺序排列
>>> collections.deque([1,2])
deque([1, 2])
>>> collections.deque({1:2})
deque([1])
>>> collections.deque([1,2,{1:2}])
deque([1, 2, {1: 2}])
>>> collections.deque([1,2,[1,2,3]])
deque([1, 2, [1, 2, 3]])
>>> d2=collections.deque("hweawsdasd",5)
>>> d2
deque(['s', 'd', 'a', 's', 'd'], maxlen=5)
#指定了n后,将使用最后n个元素,不过仍按元素在<obj>中的顺序排列

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

<deq>.append(<x>):在最右侧添加元素
  #返回None,如果没有特别说明,则下同
<deq>.appendleft(<x>):在最左侧添加元素
  #参数说明:
    deq:要添加元素的deque对象
    x:要添加的元素
      #对x的要求和创建<deq>时对<obj>的要求相同

#实例:
>>> d=collections.deque("hello world")
>>> d.append(1)
>>> d.appendleft(2)
>>> d
deque([2, 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 1])

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

<deq>.clear():清空deque对象
  #清空后<deq>的长度为0

#实例:
>>> d.clear()
>>> d
deque([])

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

<deq>.count(<x>):计算指定元素出现的次数
  #参数说明:
    x:指定要计数的元素

#实例:
>>> d=collections.deque("hello world")
>>> d.count('o')
2

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

<deq>.extend(<itrbl>):在最右侧批量添加元素
  #将<itrbl>中的元素依次添加到<deq>的最右侧
<deq>.extendleft(<itrbl>):在最左侧批量添加元素
  #将<itrbl>中的元素依次添加到<deq>的最左侧
  #参数说明:
    itrbl:指定要添加的元素;为可迭代对象

#实例:
>>> d.extend("how")
>>> d.extendleft("are")
>>> d
deque(['e', 'r', 'a', 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 'h', 'o', 'w'])
#注意.extend()和.extendleft()添加元素的顺序正好相反

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

<de>=<deq>.pop():删除最右侧的元素
  #如果没有元素,将报出IndexError
<de>=<deq>.popleft():删除最左侧的元素
  #如果没有元素,将报出IndexError
  #参数说明:
    de:返回被删除的元素

#实例:
>>> d.pop()
'w'
>>> d.popleft()
'e'
>>> d
deque(['r', 'a', 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 'h', 'o'])

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

<deq>.remove(<v>):删除指定元素
  #只删除第1次出现的指定元素,之后即使还有,也不删除
  #如果没有找到,则报出ValueError
  #参数说明:
    v:指定要删除的元素

#实例:
>>> d.remove('o')
>>> d
deque(['r', 'a', 'h', 'e', 'l', 'l', ' ', 'w', 'o', 'r', 'l', 'd', 'h', 'o'])
#注意:只删除了第1个'o'

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

<deq>.reverse():反转deque对象

#实例:
>>> d.reverse()
>>> d
deque(['o', 'h', 'd', 'l', 'r', 'o', 'w', ' ', 'l', 'l', 'e', 'h', 'a', 'r'])

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

<deq>.rotate(<n>):将<deq>分割成2部分并调换这2部分的顺序
  #参数说明:
    n:指定2部分的划分;为int
      >0时取最右侧的n个元素为1部分,其他元素为第2部分
      <0时取最左侧的|n|个元素为1部分,其他元素为第2部分

#实例:
>>> d.rotate(5)
>>> d
deque(['l', 'e', 'h', 'a', 'r', 'o', 'h', 'd', 'l', 'r', 'o', 'w', ' ', 'l'])
>>> d.rotate(-4)
>>> d
deque(['r', 'o', 'h', 'd', 'l', 'r', 'o', 'w', ' ', 'l', 'l', 'e', 'h', 'a'])

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

<deq>.maxlen:deque对象的最大长度
  #如果无解,则返回None
  #只读的属性

#实例:
>>> d.maxlen
>>> d.maxlen=10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: attribute 'maxlen' of 'collections.deque' objects is not writable
>>> d2.maxlen
5

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

deque还支持迭代/序列化/len(<deq>)/reversed(<deq>)/copy.copy(<deq>)/copy.deepcopy(<deq>)等
操作,索引的时间复杂度是在两端是O(1),在中间是O(n)(在中间部位可以使用list代替以提高效率)

7.ChainMap:

ChainMap将多个字典/其他映射组合起来,形成1个可更新的视图;如果没有maps被指定,就提供1个默认的空字典.该
数据类型是管理嵌套上下文和覆盖的有用工具

#创建ChainMap对象:
<cm>=collections.ChainMap([<map1>,<map2>...]):创建ChainMap对象
  #参数说明:
    map1,map2...:通过这些字典/映射创建ChainMap对象
      #如果不指定,则创建空ChainMap对象
    cm:返回ChainMap对象

#实例:
>>> collections.OrderedDict()
OrderedDict()
>>> m1={'apple':1,'banana':2}
>>> m2={'orange':2,'apple':3,'pike':1}
>>> c1=collections.ChainMap(m1,m2)
>>> c2=collections.ChainMap(m2,m1)
>>> c1
ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
>>> c2
ChainMap({'orange': 2, 'apple': 3, 'pike': 1}, {'apple': 1, 'banana': 2})
>>> for k,v in c1:
...     print(k,v)
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
>>> for k,v in c1.items():
...     print(k,v)
...
orange 2
apple 1
pike 1
banana 2
>>> for k,v in c2.items():
...     print(k,v)
...
apple 3
banana 2
orange 2
pike 1
>>> m3={'tofu':2}
>>> c3=collections.ChainMap(m1,m2,m3)
>>> c3
ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1}, {'tofu': 2})
>>> for k,v in c3.items():
...     print(k,v)
...
tofu 2
orange 2
apple 1
pike 1
banana 2

二.collections.abc模块

collections.abc模块中定义了一些抽象基类,为Python的内置数据类型及collections模块中的数据类型定义了API(见下图)

在这里插入图片描述
三.array模块
1.简介
(1)简介:

"数组"(array)是Python中的1种高效数据类型,被定义在array模块中.array和list类似,但所有成员的数据类型都必须相同

(2)导入:

import array

2.创建数组:

创建数组:[<a>=]array.array("<typecode>"[,<initializer>])
  #参数说明:
    typecode:指定Type code;为str(可取的值见下表)
      #即array中成员的数据类型
    initializer:指定初始值;为list/str/iterable object,默认为None
      #值可重复
    a:返回创建出的array

#实例:
>>> array.array('b')
array('b')
>>> array.array('b',[1,2])
array('b', [1, 2])
>>> array.array('u',"123")
array('u', '123')

Type code	C Type	Python Type	Minimum size in bytes
‘b’	signed char	int	1
‘B’	unsigned char	int	1
‘u’	Py_UNICODE	Unicode	2
‘h’	signed short	int	2
‘H’	unsigned short	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

3.属性:

array的Type code:<a>.typecode
array中每个成员占用的字节数:<a>.itemsize

#实例:
>>> a=array.array('h',[12,-3,2,43,-65,-7,3,11,-2,1,-2])
>>> a.typecode
'h'
>>> a.itemsize
2

4.方法
(1)增:

在结尾追加单个元素:None=<a>.append(<x>)
  #发生类型错误时,会报错
在结尾追加多个元素:None=<a>.extend(<iter>)
  #发生类型错误时,会报错
通过bytes在结尾追加元素:None=<a>.frombytes(<b>)
  #旧版中为None=<a>.fromstring(<s>),目前二者均可使用
通过file在结尾追加元素:None=<a>.fromfile(<f>,<n>)
通过list在结尾追加元素None=<a>.fromlist(<li>)
通过unicode在结尾追加元素:None=<a>.fromunicode(<u>)
  #只有<a>中元素的数据类型为unicode时才可用
在指定位置插入指定元素:None=<a>.insert(<i>,<x>)
  #参数说明:
    x:指定要增加的元素(应为单个元素)
    iter:指定要增加的元素;为iterable object
    b:指定要增加的元素;为bytes
    f:指定文件;为built-in file object
    n:指定要追加的元素数;为int
      #如果<n>大于<f>中元素的个数,会报错
    li:指定元素来源;为list
    u:指定要增加的元素;为unicode
    i:指定插入到的位置的索引;为int
      #即插入后<x>的索引

#实例:接上
>>> a.append(3)
>>> a
array('h', [12, -3, 2, 43, -65, -7, 3, 11, -2, 1, -2, 3])
>>> a.extend([111,222])
>>> a
array('h', [12, -3, 2, 43, -65, -7, 3, 11, -2, 1, -2, 3, 111, 222])
>>> a.fromlist([2,3])
>>> a
array('h', [12, -3, 2, 43, -65, -7, 3, 11, -2, 1, -2, 3, 111, 222, 2, 3])
>>> a.insert(1,5)
>>> a
array('h', [12, 5, -3, 2, 43, -65, -7, 3, 11, -2, 1, -2, 3, 111, 222, 2, 3])
>>> b=array.array('l',[1,2,3])
>>> b.frombytes(b.tobytes())
>>> b
array('l', [1, 2, 3, 1, 2, 3])
>>> b.fromlist(b.tolist())
>>> b
array('l', [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])
>>> f=open("E:1.txt","wb+")
>>> b.tofile(f)
>>> f.close()#注意:需要先关闭文件以完成写入
>>> f=open("E:1.txt","rb")
>>> b.fromfile(f,1)
>>> b
array('l', [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1])

(2)删:

删除并返回指定位置处的元素:[<x>=]<a>.pop([<i>])
删除首个指定元素:None=remove(<x>)
  #参数说明:
    i:指定要删除的元素的索引;为int,默认为-1(尾元素)
    x:指定要删除的元素

#实例:接上
>>> a.pop()
3
>>> a.pop(1)
5
>>> a.remove(-3)
>>> a
array('h', [12, 2, 43, -65, -7, 3, 11, -2, 1, -2, 3, 111, 222, 2])

(3)查:

给出内存相关信息:[(<address>,<length>)=]<a>.buffer_info()
查看指定元素出现的次数:[<t>=]<a>.count(<x>)
查看指定元素首次出现的位置:[<i>=]<a>.index(<x>)
  #参数说明:
    address:<a>的内存地址;为int
    length:<a>占用的内存的字节大小;为int
    x:要查看的值
    t:返回指定值出现的次数;为int
    i:返回指定值首次出现的位置的索引;为int

#实例:接上
>>> a.buffer_info()
(2249297319808, 14)
>>> a.count(2)
2
>>> a.index(2)
1

(4)改:

将array转换为bytes:[<b>=]<a>.tobytes()
  #在旧版中是<a>.tostring(),目前二者均可使用
将array保存到文件:None=<a>.tofile(<f>)
  #和<a>.tofile()写入的内容相同
将array转换为list:[<li>=]<a>.tolist()
将array转换为unicode:[<u>=]<a>.tounicode()
  #只有<a>中元素的数据类型为unicode时才可用
  #参数说明:
    b:返回转换成的bytes
    f:指定要保存到的文件;为file object
      #注意:打开模式应为可写的二进制模式
    li:返回转换成的list
    u:返回转换成的unicode

#实例:接上
>>> a.tobytes()
b'\x0c\x00\x02\x00+\x00\xbf\xff\xf9\xff\x03\x00\x0b\x00\xfe\xff\x01\x00\xfe\xff\x03\x00o\x00\xde\x00\x02\x00'
>>> f=open("E:1.txt",'wb+')
>>> a.tofile(f)
>>> f.close()
>>> a.tolist()
[12, 2, 43, -65, -7, 3, 11, -2, 1, -2, 3, 111, 222, 2]
>>> a.tounicode()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tounicode() may only be called on unicode type arrays

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

翻转array:None=<a>.reverse()
  #即将array中元素的顺序颠倒

#实例:接上
>>> a.reverse()
>>> a
array('h', [2, 222, 111, 3, -2, 1, -2, 11, 3, -7, -65, 43, 2, 12])

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

对每个元素进行字节交换:None=<a>.byteswap()

#实例:接上
>>> a.byteswap()
>>> a
array('h', [512, -8704, 28416, 768, -257, 256, -257, 2816, 768, -1537, -16385, 11008, 512, 3072])