结构

  • 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()

反转数组中项目的顺序。