结构

  • 1. 明确数组类型
  • 2. 定义
  • class array.array(typecode[, initializer])
  • 3.方法和常量
  • 3.1 常量
  • array.typecodes 常量
  • 3.2 方法
  • 3.2.1 通用序列方法
  • 3.2.2 转换类型的方法
  • array.tobytes()
  • array.frombytes(s)
  • array.tofile(f)
  • array.fromfile(f,n)
  • array.tolist()
  • array.fromlist(list)
  • ~~array.tostring()~~ 废弃
  • ~~array.fromstring()~~ 废弃
  • array.tounicode()
  • array.fromunicode(s)
  • 3.2.3 其他方法
  • array.typecode
  • array.itemsize
  • array.append(x)
  • array.buffer_info()
  • array.byteswap()
  • array.count(x)
  • array.extend(iterable)
  • array.index(x)
  • array.insert(i,x)
  • array.pop([i])
  • array.remove(x)
  • array.reverse()


1. 明确数组类型

该模块定义了一个对象类型，它可以紧凑地表示基本值的数组：字符，整数，浮点数。

数组是序列类型，其行为与列表非常相似，只是存储在其中的对象类型受到约束。通过使用类型代码在对象创建时指定存储的类型，类型代码是单个字符，有以下选择：

类型代码

C类型

python类型

最小字节

注意点

'b'

signed char

int

1

'B'

unsigned char

int

1

'u'

Py_UNICODE

Unicode character

2

(1)

'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

(2)

'Q'

unsigned long long

int

8

(2)

'f'

float

float

4

'd'

double

float

8

注意点：

（1）'u'的类型代码对应于Python的过时的Unicode字符（Py_UNICODE就是wchar_t）。根据平台的不同，它可以是16位或32位。

'u’将与Py_UNICODE API 的其余部分一起删除。

从版本3.3开始不推荐使用，将在4.0版中删除。

（2）'q'和'Q'类型代码只能用在下面的情况，C编译器用来编辑python支持的long long类型，或者在Windows上的__int64类型。

版本3.3中的新功能。

值的实际表示由机器体系结构确定（严格地说，由C实现）。可以通过itemsize属性访问实际大小。

2. 定义

该模块定义以下类型：

class array.array(typecode[, initializer])

一个新数组，其项目受typecode限制，并从可选的initializer进行初始化，initializer必须是列表，类字节对象，或者适当类型（可以在其元素上进行迭代）。

如果给一个列表或字符串，initializer被传递给新数组的 fromlist()，frombytes()或fromunicode()方法（见下文），初始项添加到数组中。另一方面，可迭代的initializer将传递给extend()方法。

def array_create():
    a = array.array('l', [1, 2, 3, 4, 5])
    print(a)
    b = array.array('b',b'0110ae')
    print(b)
    c = array.array('u', 'abc')
    print(c)
# 输出结果
array('l', [1, 2, 3, 4, 5])
array('b', [48, 49, 49, 48, 97, 101])
array('u', 'abc')

3.方法和常量

3.1 常量

array.typecodes 常量

包含所有可用类型代码的字符串。

typecodes = 'bBuhHiIlLqQfd'

3.2 方法

3.2.1 通用序列方法

数组对象支持索引，切片，连接和乘法等所有 通用序列操作。使用切片分配或赋值时，指定的值必须是与数组对象具有相同类型代码; 其他情况下，报异常TypeError。数组对象也实现缓冲区接口，并且可以在支持类字节对象的任何地方使用。

# 通用序列操作
def array_opt():
    a = array.array('l', [1, 2, 3, 4, 5])
    b = array.array('l', [6,7,8])
    print(3 in a)
    print(a+b)
    print(b*3)
    print(a[3])
    print(a[:4])
    print(len(a))
    print(min(a))
# 输出结果
True
array('l', [1, 2, 3, 4, 5, 6, 7, 8])
array('l', [6, 7, 8, 6, 7, 8, 6, 7, 8])
4
array('l', [1, 2, 3, 4])
5
1

还支持以下数据项和方法：

3.2.2 转换类型的方法

array.tobytes()

将数组转换为机器值数组并返回字节表示形式（tofile()方法将写入文件的相同字节序列。）
版本3.2中的新功能：为了清晰起见，tostring()重命名tobytes()为。

array.frombytes(s)

从字符串中追加项目，将字符串解释为机器值数组（就好像它是使用fromfile()方法从文件中读取的一样）。

版本3.2中的新功能：为了清晰起见，fromstring()重命名为frombytes()。

def array_bytes():
    a = array.array('l', [1, 2, 4, 8, 16])
    c = a.tobytes()
    print(c)
    b = array.array('l')
    b.frombytes(c)
    print(b)
# 输出结果
b'\x01\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x08\x00\x00\x00\x10\x00\x00\x00'
array('l', [1, 2, 4, 8, 16])
array.tofile(f)

将所有项目（作为机器值）写入文件对象 f。

array.fromfile(f,n)

从文件对象 f中读取n个项目（作为机器值）并将它们附加到数组的末尾。如果可用的项目少于n个， 则会引发EOFError，但可用的项目仍会插入到数组中。f必须是一个真正的内置文件对象; 使用非read()是不行的。

def array_file():
    a = array.array('l', [1, 2, 4, 8, 16])
    fp = open('files.txt','wb')
    a.tofile(fp)
    fp.close()

    fp = open('files.txt','rb')
    b = array.array('l')
    b.fromfile(fp,len(a))
    print(b)
# 输出结果
array('l', [1, 2, 4, 8, 16])
array.tolist()

将数组转换为具有相同项的普通列表。

array.fromlist(list)

附加列表中的项目。这相当于for x in list: a.append(x)，除了存在类型错误外，数组不变。

def arraylist():
    a = [1, 2, 4, 8, 16]
    b = array.array('l')
    b.fromlist(a)
    print(b)
    c = b.tolist()
    print(c)
# 输出结果
array('l', [1, 2, 4, 8, 16])
[1, 2, 4, 8, 16]
array.tostring()

已弃用，替代品 array.tobytes()

array.fromstring()

已弃用，替代品 array.frombytes()

array.tounicode()

将数组转换为unicode字符串。数组必须是类型'u'; 否则报错ValueError。用array.tobytes().decode(enc)从某种其他类型的数组中获取unicode字符串。

array.fromunicode(s)

使用给定unicode字符串中的数据扩展此数组。数组必须是类型’u’数组; 否则a ValueError被提出。使用 array.frombytes(unicodestring.encode(enc))为Unicode数据追加到一些其它类型的数组中。

def array_opt():
   a = array.array('u','abc')
   ua = a.tounicode()
   print("a:",a)
   b = array.array('u')
   b.fromunicode(ua)
   print("b:",b)
   
   c = array.array('l',[1,2,3,4,5])
   
   d = c.tobytes().decode()
   print(d)
   print(type(d))
   e = array.array('l')
   e.frombytes(d.encode())
   print(e)
   print(type(e))
# 输出结果
a: array('u', 'abc')
b: array('u', 'abc')
xxaa乱码想？df
<class 'str'>
array('l', [1, 2, 3, 4, 5])
<class 'array.array'>

3.2.3 其他方法

array.typecode

用于创建数组的typecode字符。

print(a.typecode)
#输出结果
l
array.itemsize

表示中数组内一个对象的长度（以字节为单位）。

print(a.itemsize)
#输出结果
4
array.append(x)

将值为x的新项追加到数组的末尾。

array.buffer_info()

返回一个元组(address, length)，给出当前内存地址和用于保存数组内容的缓冲区元素的长度。内存缓冲区的大小（以字节为单位）可以计算为array.buffer_info()[1] * array.itemsize。当使用需要内存地址的低级（和固有不安全）I / O接口（例如某些ioctl()操作）时，这偶尔会很有用 。只要数组存在且没有长度更改，返回的数字就是有效的。

注意 当使用用C或C ++编写的代码中的数组对象（有效利用这些信息的唯一方法）时，使用数组对象支持的缓冲区接口更有意义。维护此方法是为了向后兼容，应在新代码中避免使用。缓冲区接口记录在缓冲区协议中。

print(a.buffer_info())
#输出结果
(1889189737000, 5)
array.byteswap()

“Byteswap”数组中的所有项目（字节反转）。仅支持大小为1,2,4或8字节的值; 对于其他类型的值，引发RuntimeError。从具有不同字节顺序的机器上写入的文件中读取数据时，它非常有用。

a = array.array('l', [1, 2, 4, 8, 16])
a.byteswap()
print(a)
print("\n".join("len:{} ,{:b}".format(int.bit_length(_),_) for _ in a))
array('l', [16777216, 33554432, 67108864, 134217728, 268435456])
len:25 ,1000000000000000000000000
len:26 ,10000000000000000000000000
len:27 ,100000000000000000000000000
len:28 ,1000000000000000000000000000
len:29 ,10000000000000000000000000000
array.count(x)

返回数组中x的出现次数。

array.extend(iterable)

将项目从iterable追加到数组的末尾。如果iterable是另一个数组，它必须具有完全相同的类型代码; 如果没有，将报错TypeError。如果iterable不是数组，则它必须是可迭代的，并且其元素必须是要附加到数组的正确类型。

array.index(x)

返回最小的i，使得i是数组中第一次出现x的索引 。

array.insert(i,x)

在位置i之前的数组中插入值为x的新项。负值被视为相对于数组的末尾。

array.pop([i])

从数组中删除索引为i的项并返回它。可选参数默认为-1，因此默认情况下会删除并返回最后一项。

array.remove(x)

从数组中删除第一个x。

array.reverse()

反转数组中项目的顺序。