大多数pythoneer只知道有列表清楚知道python也有数组原创

阵列和列表

Python中的数组和列表是不同的，我敢断言大多数pythoneer只知道有列表，并且知道python也有数组数组。列表是一个包含不同数据类型的元素集合，而吞吐量是一个只含相同数据类型的元素集合。

Python的 array库是一个提供阵列操作的模块，它提供了一种用于存储和处理多个相同类型元素的容器。与Python的列表列表相比，阵列阵列在存储和操作大量数值型数据时更为重要，因为它在内存中以高效的连续方式存储数据，占用的内存空间更小。

内存创建

数组 (类型代码 [, 初始值设定项]) -> 数组

返回一个新的磁盘，该磁盘的项受类型代码的限制，并通过可选的初始值设定项值进行初始化，该值必须是列表、字符串或可在适当类型的元素上迭代。

数据库表示基本值，其行为与列表非常相似，只是其中存储的对象类型受到约束。类型是在对象创建时使用类型代码指定的，该代码是单个字符。

类型代码 类型代码

< td style="border-color:#000000;text-align:center;vertical-align:middle;width:183px;">'u'

类型	C类型	最小字节
'b'	有符号整数	1
'B'	无符号整数	1
Unicode 字符	2
'h'	有符号整数	2
'H'	无符号整数	2
'i'	有符号整数	2
'我'	无符号整数	2
'l'	有符号整数	4
'L'	无符号整数	4
'q'	有符号整数	8
'Q'	无符号整数r	8
'f'	浮点	4
'd'	浮点	8

创建数据库

导入数组
arr = array.array('i', [1, 2, 3, 4, 5])  #创建一个整数类型的数据库
arr = array.array('u', 'abcde')  # 创建一个字符类型的集群

类型属性

import array  
arr = array.array( 'i', [1, 2, 3, 4, 5])
print(arr.typecode)   # 打印备份类型 i

备份切片

与列表最常用相同：

>>> arr = array.array('i', [1, 2, 3, 4, 5])
>>> arr[0]
1
>>> arr[2]
3
>>> arr[-1]
5
>>> arr[:3]
数组('i', [1, 2, 3])
>>> arr[3:]
array('i', [4, 5])
>>> arr[ :-1]
array('i', [1, 2, 3, 4])
>>> arr[::-1]
array('i', [5 , 4, 3, 2, 1])
>>> arr[1::2]
array('i', [2, 4])
>>> arr[0 ::2]
array('i', [1, 3, 5])

类型转换

可以将浮点数转换为浮点数，反之不行。

>>> arr1 = 数组.array('i', [1, 2, 3, 4, 5])
>>> arr1
array('i', [1, 2, 3, 4, 5])
/> >>> arr2 = array.array('f', arr1)
>>> arr2
array('f', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> arr3 = array.array('i', arr2)
回溯（最近一次调用最后一次）：
  文件“”，第 1 行，位于
    arr3 = array.array('i', arr2)
TypeError: 'float' object不能被解释为整数

内存与列表占用内存的比较

import sys, array
arr = array.array('i', [_ for _ in range(1024)])
lst = [_ for _ in range(1024)]

print(sys.getsizeof(arr))  # 输出：4176 array对象本身的大小
print(sys.getsizeof(lst))  # 输出：8856 Listlist对象本身的大小  
# 注意：这些值可能因操作系统或Python解释器的实现和版本而不同。

备份方法

append()--将一个新项追加到内存的开销

buffer_info()--返回当前内存信息的信息

byteswap()--字节交换阵列的所有项目

计数()--返回对象的出现次数

extend()--通过从可迭代项中附加多个元素来扩展仓库

fromfile()--从文件对象读取项< /p>

fromlist()--从列表中追加项

frombytes()--从字符串中追加项

< strong>fromunicode()--从unicode字符串中追加项

索引< /span>()--返回对象第一次出现的索引

insert()--在吞吐量中提供的位置插入一个新项

pop()-- 删除并返回项（默认为最后一个）

remove()--对象删除的第一个出现项< /p>

反向()--堆叠中项目的顺序

tofile()--将所有项写入文件对象

tolist< /span>()--返回转换为普通列表的集群

tobytes( )--返回转换为字符串的批量

在示例讲解中先来复习一个列表列表的方法，对应相同的绿色（标注）可以简单不学：

< p>追加(self, object, /)
    将对象追加到列表末尾。

清除（self, /）
    从列表中删除所有项目。

< strong>复制(self, /)
    返回列表的浅表副本。

计数(self, value, /)
    返回值出现的次数。

< span style="color:#1c7331;">扩展(self, iterable, /)
通过附加可迭代元素来扩展列表。

index(self, value, start=0, stop =9223372036854775807, /)
    返回值的第一个索引。
    如果值不存在，则引发 ValueError。

insert(self, index, object, /)
    在索引之前插入对象。

pop (self, index=-1, /)
    删除并返回索引处的项目（默认为最后一个）。
    如果列表为空或索引超出范围，则引发 IndexError。

删除(self, value, /)
    删除第一个出现的值。
    如果值不存在，则引发 ValueError。

反向(self, /)
    反转*就位*。

排序(self, /, *, key=None, reverse=False)
    按升序对列表进行排序并返回 None。

便捷讲解

buffer_info()

返回当前快照的内存信息。

import array
arr = array.array('i', [1, 2, 3])
buffer_info = arr.buffer_info()
print(buffer_info)  # 输出包含内存地址、大小等信息的元组

byteswap()

字节交换阵列的所有项，通常用于处理二进制数据的不同字节顺序。

导入array
arr = array.array('i', [0x12345678])  # 假设这是一个32位整数  
arr.byteswap()
print(arr)  # 输出：[305419896] (0x78563412)

fromfile()

从文件对象中读取项，通常用于从二进制文件中读取数据。

import array
with open('data.bin', 'rb') as f:
    arr = array.array('i')
    arr.fromfile(f, 3)  # 从文件中读取3个整数  
print(arr)  # 输出：假设文件中有3个整数，则输出这些整数构成的数组

< h5>fromlist()

从列表中追加项，创建一个新的集群。

导入数组
list_data = [1, 2, 3, 4, 5]
arr = array.array('i', list_data)
print(arr)  # 输出：array('i', [1, 2, 3, 4, 5])

< h5>frombytes()

从字节字符串中追加项创建一个新的数据库。

import array
byte_data = b'\x01\x02\x03\x04'
arr = array.array('B', byte_data)  # 'B' 表示无符号字符  
print(arr ) # 输出：array('B', [1, 2, 3, 4])

tofile()

将所有项写入文件对象，通常用于将写入数据写入二进制文件。

import array
arr = array.array('i', [1, 2, 3])
with open('output.bin', 'wb') as f:
    arr.tofile(f)
# 现在'output.bin'文件包含队列的数据< /p>

tolist()

返回转换为普通列表的集群。

import array
arr = array.array('i', [1, 2, 3])
list_data = arr.tolist()
print(list_data)  # 输出：[1, 2,3]

tobytes()

返回字节字符串的存储。

< p>import array
arr = array.array('i', [1, 2, 3])
byte_data = arr.tobytes()
print(byte_data)  # 输出：b' \x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'

最简单

实例1

 import array # 创建一个浮点类型的数组实例 float_array = array.array('f', [1.0, 2.0, 3.0, 4.0, 5.0]) # 打印原始数据 print(" Original Array:", float_array) # 计算每个元素的平方 squared_array = array.array('f') for num in float_array: squared_array.append(num ** 2) # 打印平方配额 print("Squared Array:", squared_array) # 每个立方的计算元素cubed_array = array.array('f') for num in float_array:cubed_array.append(num ** 3) # 打印立方数组 print("Cubed Array:",cubed_array) # 计算平方和立方阵列的和 sum_squared = sum(squared_array) sum_cubed = sum(cubed_array) # 打印和 print("Sum of Squared:", sum_squared) print("三次求和：", sum_cubed)

输出结果：

原始数组: array('f', [1.0, 2.0 , 3.0, 4.0, 5.0])
平方数组: array('f', [1.0, 4.0, 9.0, 16.0, 25.0])
立方数组: array('f', [1.0, 8.0 , 27.0, 64.0, 125.0])
平方和：55.0
立方和：225.0

实例2

import array # 原始字符串original_string = "Hello, World!" # 将字符串转换为字符存储 # 注意：'u' 类型用于存储 Unicode 字符，但在 Python 3 中，'u' 类型已被废弃 # 我们应该使用 'U' 类型来存储 Unicode 字符（码点） ，但通常用于宽字符集 # 这里示例中，我们将使用字节数据库 'b' 并通过编码字符串来处理它 # 编码原始字符串为字节encoded_string = origin_string.encode('utf-8 ') # 创建一个字节类型的数组实例 byte_array = array.array('b',encoded_string) # 打印字节数组 print("Byte Array:", byte_array) # 查找特定字节（例如替换 'o' 字符）的字节表示） # 注意：这里我们查找的是 'o'； UTF-8 编码的第一个字节 # 在 ASCII 中，'o' 的编码是 0x6F，但在 UTF-8 编码的字符串中，我们需要找到正确的字节序列 # 对于简单的 ASCII 字符，UTF-8编码与ASCII相同编码 target_byte = ord('o') # 获取'o'字符的ASCII码点值 target_indices = [i for i, b in enumerate(byte_array) if b == target_byte] print(" Indexs of 'o':", target_indices) # 替换所有 'o' 字符的字节表示为另一个字符（例如 'x'） # 注意：直接替换可能破坏 UTF-8 编码的多字节字符序列 # 因此，这个例子仅适用于单字节字符（ASCII范围内）的字符串 replacement_byte = ord('x') # 获取 'x' 字符的 ASCII 码点值 for i in target_indices: byte_array[i] = replacement_byte # 将修改后的字节阵列转换回字符串 #注意：如果替换了多字节字符的部分，解码可能会失败尝试：modified_string = byte_array.tobytes().decode('utf-8') print("Modified String :", modded_string) except UnicodeDecodeError: print("由于 UTF-8 序列无效，解码失败。") # 注意：在处理中包含非 ASCII 字符的字符串时，应该小心，#因为UTF-8编码可能会使用多个字节来表示一个字符。#在这种情况下，直接替换单个字节可能会破坏字符的编码。

输出结果：

Byte Array: array('b', [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33])
'o'的索引：[4, 8]
修改后的字符串：Hellx, Wxrld!

实例3

import array # 创建一个整数类型的数组实例 int_array = array.array('i', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) # 打印原始队列 print( "Original Integer Array:", int_array) # 将数据库读取文件 with open('int_array.bin', 'wb') as f: int_array.tofile(f) # 打开文件以二进制数据读取 with open('int_array) .bin', 'rb') as f: # 读取整个文件到内存中 # 由于知道文件中的数据类型和大小，我们可以创建使用这些信息来内存 # 假设文件中的整数是32位的（即 'i' 表示整数），并且我们不知道有多少个整数 # 我们可以先读取文件的大小，然后除以整数的字节大小来得到整数的数量 file_size = f.seek(0, 2) #移动到文件以获取文件大小 num_ints = file_size // 4 # 假设整数是32位的（4字节）f.seek(0) # 将文件指针重置回文件 # 创建一个空的数组实例，用于存储读取的数据 read_array = array.array('i') # 从文件中读取整数数据到内存read_array.fromfile(f, num_ints) # 打印从文件中读取的集群 print("Array Read from File:", read_array) # 验证两个集群是否相同 assert int_array == read_array print("The arrays are the same .")

输出结果：

原始整数数组: array('i', [1, 2, 3, 4, 5, 6, 7, 8 , 9, 10])
从文件读取数组： array('i', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
数组为一样的。

---

完成。