bool-hybrid-array 9.6.4__py3-none-any.whl → 9.10.19__py3-none-any.whl

bool_hybrid_array/int_array/__init__.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+from ..core import *
+import builtins
+
+class IntBitTag(BHA_Bool, metaclass=ResurrectMeta):
+    def __str__(self):
+        return "'-1'" if (hasattr(self, 'is_sign_bit') and self.is_sign_bit and self) else "'1'" if self else "'0'"
+    __repr__ = __str__
+
+class IntHybridArray(BoolHybridArray):
+    def __init__(self, int_array: list[int], bit_length: int = 8):
+        self.bit_length = bit_length
+        bool_data = []
+        max_required_bits = 1
+        for num in int_array:
+            if num == 0:
+                required_bits = 1
+            else:
+                abs_num = abs(num)
+                num_bits_needed = abs_num.bit_length()
+                required_bits = 1 + num_bits_needed
+            if required_bits > max_required_bits:
+                max_required_bits = required_bits
+        self.bit_length = max_required_bits
+        for num in int_array:
+            if num >= 0:
+                sign_bit = False
+                num_bits = [bool((num >> i) & 1) for i in range(self.bit_length - 1)]
+            else:
+                sign_bit = True
+                abs_num = abs(num)
+                num_bits = [not bool((abs_num >> i) & 1) for i in range(self.bit_length - 1)]
+                carry = 1
+                for j in range(len(num_bits)):
+                    if carry:
+                        num_bits[j] = not num_bits[j]
+                        carry = 0 if num_bits[j] else 1
+            bool_data.append(sign_bit)
+            bool_data.extend(num_bits)
+        self.total_bits = len(bool_data)
+        super().__init__(0, self.total_bits, False, IntBitTag, False)
+        for idx in range(self.total_bits):
+            if idx < self.size:
+                super().__setitem__(idx, bool_data[idx])
+            else:
+                super().append(bool_data[idx])
+        for i in range(0, self.total_bits, self.bit_length):
+            if i < self.size:
+                bit_tag = super().__getitem__(i)
+                bit_tag.is_sign_bit = True
+
+    def to_int(self, bit_chunk):
+        sign_bit = bit_chunk[0].value
+        num_bits = [bit.value for bit in bit_chunk[1:]]
+        if not sign_bit:
+            num = 0
+            for j in range(len(num_bits)):
+                if num_bits[j]:
+                    num += (1 << j)
+        else:
+            num_bits_inv = [not b for b in num_bits]
+            carry = 1
+            for j in range(len(num_bits_inv)):
+                if carry:
+                    num_bits_inv[j] = not num_bits_inv[j]
+                    carry = 0 if num_bits_inv[j] else 1
+            num = 0
+            for j in range(len(num_bits_inv)):
+                if num_bits_inv[j]:
+                    num += (1 << j)
+            num = -num
+        return num
+
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            start, stop, step = key.indices(len(self))
+            result = []
+            for i in range(start, stop, step):
+                block_start = i * self.bit_length
+                block_end = block_start + self.bit_length
+                if block_end > self.size:
+                    raise IndexError("索引超出范围")
+                bit_chunk = [super().__getitem__(j) for j in range(block_start, block_end)]
+                num = self.to_int(bit_chunk)
+                result.append(num)
+            return IntHybridArray(result, self.bit_length)
+        key = key if key >= 0 else key + len(self)
+        if not (0 <= key < len(self)):
+            raise IndexError("索引超出范围")
+        block_start = key * self.bit_length
+        block_end = block_start + self.bit_length
+        if block_end > self.size:
+            raise IndexError("索引超出范围")
+        bit_chunk = [super().__getitem__(j) for j in range(block_start, block_end)]
+        return self.to_int(bit_chunk)
+
+    def __setitem__(self, key, value):
+        value = int(value)
+        if isinstance(key, slice):
+            start, stop, step = key.indices(len(self))
+            values = list(value) if isinstance(value, (list, tuple, IntHybridArray)) else [value] * ((stop - start + step - 1) // step)
+            idx = 0
+            for int_idx in range(start, stop, step):
+                block_start = int_idx * self.bit_length
+                block_end = block_start + self.bit_length
+                if block_end > self.size:
+                    raise IndexError("索引超出范围")
+                num = values[idx % len(values)]
+                if num >= 0:
+                    sign_bit = False
+                    num_bits = [bool((num >> i) & 1) for i in range(self.bit_length - 1)]
+                else:
+                    sign_bit = True
+                    abs_num = abs(num)
+                    num_bits = [not bool((abs_num >> i) & 1) for i in range(self.bit_length - 1)]
+                    carry = 1
+                    for j in range(len(num_bits)):
+                        if carry:
+                            num_bits[j] = not num_bits[j]
+                            carry = 0 if num_bits[j] else 1
+                bool_data = [sign_bit] + num_bits
+                for bit_idx in range(self.bit_length):
+                    super().__setitem__(block_start + bit_idx, bool_data[bit_idx])
+                idx += 1
+            return
+        key = key if key >= 0 else key + len(self)
+        if not (0 <= key < len(self)):
+            raise IndexError("索引超出范围")
+        block_start = key * self.bit_length
+        block_end = block_start + self.bit_length
+        if block_end > self.size:
+            raise IndexError("索引超出范围")
+        num = value
+        if num >= 0:
+            sign_bit = False
+            num_bits = [bool((num >> i) & 1) for i in range(self.bit_length - 1)]
+        else:
+            sign_bit = True
+            abs_num = abs(num)
+            num_bits = [not bool((abs_num >> i) & 1) for i in range(self.bit_length - 1)]
+            carry = 1
+            for j in range(len(num_bits)):
+                if carry:
+                    num_bits[j] = not num_bits[j]
+                    carry = 0 if num_bits[j] else 1
+        bool_data = [sign_bit] + num_bits
+        for bit_idx in range(self.bit_length):
+            super().__setitem__(block_start + bit_idx, bool_data[bit_idx])
+
+    def __iter__(self):
+        for i in range(0, self.total_bits, self.bit_length):
+            if i + self.bit_length > self.size:
+                break
+            bit_chunk = [super().__getitem__(j) for j in range(i, i + self.bit_length)]
+            yield self.to_int(bit_chunk)
+
+    def __str__(self):
+        return f"IntHybridArray([{', '.join(map(str, self))}])"
+    __repr__ = __str__
+
+    def __len__(self):
+        return self.total_bits // self.bit_length
+    def __delitem__(self, index: int = -1):
+        index = index if index >= 0 else index + len(self)
+        if not (0 <= index < len(self)):
+            raise IndexError("删除索引超出范围")
+        target_num = self[index]
+        pop_bit_start = index * self.bit_length
+        pop_bit_end = pop_bit_start + self.bit_length
+        for _ in range(self.bit_length):
+            super().__delitem__(pop_bit_start)
+        self.total_bits -= self.bit_length
+    def index(self, value):
+        value = int(value)
+        x = f"{value} 不在 IntHybridArray 中"
+        for idx in range(len(self)+2>>2):
+            if self[idx] == value:
+                return idx
+            elif self[-idx] == value:
+                x = len(self)-idx
+        if x != f"{value} 不在 IntHybridArray 中":
+            return x
+        raise ValueError(x)
+    def rindex(self, value):
+        value = int(value)
+        x = f"{value} 不在 IntHybridArray 中"
+        for idx in range(len(self)+2>>2):
+            if self[-idx] == value:
+                return -idx
+            elif self[idx] == value:
+                x = -(len(self)-idx)
+        if x != f"{value} 不在 IntHybridArray 中":
+            return x
+        raise ValueError(x)
+    def extend(self, iterable:Iterable) -> None:
+        if isinstance(iterable, (Iterator, Generator, map)):
+            iterable,copy = itertools.tee(iterable, 2)
+            len_ = sum(1 for _ in copy)
+        else:
+            len_ = len(iterable)
+        self.total_bits += len_*self.bit_length
+        for i,j in zip(range(len_),iterable):
+            self[-i-1] = j

bool_hybrid_array//321/207/320/267/320/250/321/205/320/277/320/226.md

@@ -0,0 +1,2 @@
+# **作者的秘密：我才10岁！！！**
+

{bool_hybrid_array-9.6.4.dist-info → bool_hybrid_array-9.10.19.dist-info}/METADATA

@@ -1,24 +1,39 @@
 Metadata-Version: 2.4
 Name: bool-hybrid-array
-Version: 9.6.4
+Version: 9.10.19
 Summary: 一个高效的布尔数组（密集+稀疏混合存储，节省内存）
+Home-page: https://github.com/BKsell/bool-hybrid-array
 Author: 蔡靖杰
 Author-email: 1289270215@qq.com
+Project-URL: GitHub 主站, https://github.com/BKsell/bool-hybrid-array
+Project-URL: GitHub 中文镜像, https://www.github-zh.com/projects/1083175506-bool-hybrid-array
+Project-URL: Issue 反馈（主站）, https://github.com/BKsell/bool-hybrid-array/issues
 Keywords: boolean array,compact storage
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.19.0
+Provides-Extra: int-array
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
+Dynamic: home-page
 Dynamic: keywords
 Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -29,7 +44,7 @@ Dynamic: summary
 
 ## ***注：大版本号更新并非不兼容更新，而是重大更新***
 
- ***注意：目前社区中若存在名称类似（如包含 “bool-hybrid-array”+ 后缀、boolean_array、validate.io-boolean-array）的库，均与本项目（bool-hybrid-array）无关联，本项目的所有功能设计、代码实现均为独立开发；***
+***注意：目前社区中若存在名称类似（如包含 “bool-hybrid-array”+ 后缀、boolean\_array、validate.io-boolean-array）的库，均与本项目（bool-hybrid-array）无关联，本项目的所有功能设计、代码实现均为独立开发；***
 ***其他平台里的类似名库绝不是我的库***
 
 ***注意：若你的原bool-hybrid-array库版本<7.10.9，看到此版本请立即更新到>=7.10.9版本，其他版本的导入都有问题！！！***
@@ -65,14 +80,16 @@ pip install -U bool-hybrid-array
 * **操作便捷**：支持类似列表的索引、切片和赋值操作
 * **快速统计**：内置高效的计数和布尔判断方法
 * **速度优势**：修改元素的时间还不比list慢
+
 ## 快速开始
 
 ### 基本用法
+
 ```python
 
 # 导入类
 
-from bool_hybrid_array import BoolHybridArr,TruesArray,FalsesArray
+from bool_hybrid_array import *
 
 # 创建实例
 
@@ -88,17 +105,24 @@ print(arr[0])  # 输出: True；
 
 print(arr[1:4])  # 输出:  BoolHybridArr([False, True, False])；
 
-print(arr2)  # 输出:  BoolHybridArr(True, True, True])；
+print(arr2)  # 输出:  BoolHybridArr([True, True, True])；
 
 print(arr3)  # 输出:  BoolHybridArr([False, False, False])；
 ```
+
 # 联系方式
 
 * 若遇到 Bug 或有功能建议，可发送邮件至：1289270215@qq.com（更正规）
 * 微信联系：18250730129（注：这是微信绑定的电话号码，优先微信沟通，请勿拨打电话哦）（微信联系回复最快）
-* 抖音（绑定电话号码同微信）（有群聊，加入可讨论）
+* 抖音（绑定的电话号码同微信）（有讨论群，加入可讨论）
+
+# GitHub仓库
+
+英文版：[bool-hybrid-array.git](https://github.com/BKsell/bool-hybrid-array.git)
+中文版：[1083175506-bool-hybrid-array](https://www.github-zh.com/projects/1083175506-bool-hybrid-array)
 
 # 修改元素
+
 ```python
 
 arr[2] = False
@@ -106,7 +130,9 @@ arr[2] = False
 print(arr)  # 输出: BoolHybridArr([True, False, False, False, True])
 
 ```
+
 ### 存储优化
+
 ```python
 
 # 创建包含大量布尔值的数组（大部分为False）
@@ -115,14 +141,16 @@ big_arr = BoolHybridArr([i % 100 == 0 for i in range(10000)])
 
 # 查看存储模式（此时应为稀疏模式）
 
-print(repr(big_arr))  # 输出: BoolHybridArray(split_index=100,size=10000,is_sparse=True,small_len=100,large_len=)不好意思large\_len我不知道
+print(repr(big_arr))  # 输出: BoolHybridArray(split_index=100,size=10000,is_sparse=True,small_len=100,large_len=)不好意思large_len我不知道
 
 # 自动优化存储
 
 big_arr.optimize()
 
 ```
+
 ### 其他功能
+
 ```python
 
 # 统计True的数量
@@ -185,7 +213,7 @@ big_arr.optimize()  # 调用优化方法
 
 print(big_arr.memory_usage(detail=True)["是否需要优化"])#"否"
 
-'''当处理动态变化的布尔数组（如频繁增删元素）时，建议在关键操作后调用memory_usage(detail=True)检查状态，通过optimize()保持最优性能。'''
+'''当处理动态变化的布尔数组（如频繁增删元素）时，建议在关键操作后调用memory\_usage(detail=True)检查状态，通过optimize()保持最优性能。'''
 
 #将数组转为int类型（7.11.0新增）：
 
@@ -221,10 +249,9 @@ print(arr << -1)  # 负数左移：等价于右移1位 → [True]
 
 #兼容numpy数组（8.0.0版本新增）
 
-arr_BoolHybridArray = BoolHybridArr([])
+arr_BoolHybridArray = BoolHybridArr(\[])
 arr_BoolHybridArray <<= 10
 arr_BoolHybridArray <<= 10000
-arr_BoolHybridArray <<= 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 array_numpy = np.array([arr_BoolHybridArray,arr_BoolHybridArray])
 
 #支持哈希（8.2.0版本新增）
@@ -232,6 +259,7 @@ array_numpy = np.array([arr_BoolHybridArray,arr_BoolHybridArray])
 set_ = {arr_BoolHybridArray}#不会报错呦
 
 ```
+
 # ***v9.0.0重大更新***
 
 ```python
@@ -298,10 +326,90 @@ def toggle_range(self, start: int, end: int):
 
 arr.toggle_range(0,1)
 
-print(arr)#输出：翻转 {0}-{1} 后：BoolHybridArr(False,True,True)
+print(arr)#输出：翻转 {0}-{1} 后：BoolHybridArr([False,True,True])
+
+toggle_range(arr,0,1)#输出：翻转 {0}-{1} 后：BoolHybridArr([True,False,True])
+
+#view方法（9.7.0新增）：
+
+arr2 = arr.view()
+
+arr2.extend([F,T])
+
+arr2[2] = F
+
+print(arr) #输出：BoolHybridArr([True,False,False,False,True])
+
+#python 3.9以下的版本泛型、联合类型支持（9.8.0新增）
+
+print(BHA_List[BoolHybridArray])#输出：bool_hybrid_array.BHA_List[bool_hybrid_array.BoolHybridArray]
+
+print(BHA_List|BoolHybridArray)#输出：typing.Union[bool_hybrid_array.BHA_List, bool_hybrid_array.BoolHybridArray] （python 3.9以下）或 bool_hybrid_array.BHA_List|bool_hybrid_array.BoolHybridArray（python 3.10以上）
+
+#BHA_Function动态创建函数（9.9.0新增）：
+
+toggle_range = BHA_Function.string_define(
+name = 'toggle_range',
+text = 
+'''
+    for i in range(start, end + 1):
+        self[i] = not self[i]  # 通过 self 操作实例的元素
+    print(f"翻转 {start}-{end} 后：", self)''',
+positional = ('self','start', 'end'),
+default = {})
+toggle_range([0,0,1],0,1)#输出：翻转 0-1 后： [True, True, 1]
+
+#开放ProtectedBuiltinsDict类型（9.9.3+）
+
+Dict = ProtectedBuiltinsDict({'1':1,'2':2},protected_names = ['1','3'],name = 'Dict')
+
+Dict['2'] = 1
+
+print(Dict) #输出：{'1': 1, '2': 1}
+
+try:Dict['1'] = 2
+except Exception as e:print(e) #输出：禁止修改内置常量：__Dict__['1']
+
+#Ask_BHA和Create_BHA（9.10.0新增）：
+
+arr = BoolHybridArr([T,F,F,F,T,T,F,F,F,T])
+arr2 = BoolHybridArr([F,F,F,F,T,T,F,T,T,F])
+
+arr3 = BHA_List([arr,arr2])
 
-toggle_range(arr,0,1)#输出：翻转 {0}-{1} 后：BoolHybridArr(True,False,True)
+Create_BHA("single_bool_array",arr3)#自动生成single_bool_array.bha文件
 
+print(Ask_BHA("single_bool_array"))
+
+'''
+输出：
+BHA_List([
+BoolHybridArr([True,False,False,False,True,True,False,False,False,True]),
+BoolHybridArr([False,False,False,False,True,True,False,True,True,False]),
+])
+'''
+
+#numba_opt函数优化（9.10.4版本新增）
+try:numba_opt()
+except:print("请先安装numba库！！！")
+
+#int_array模块（9.10.10新增）：
+
+max_num = (1 << 256) - 1
+min_num = -max_num
+
+# 1. IntHybridArray：257位完美存储
+arr_hybrid = int_array.IntHybridArray([max_num, min_num, 123456], bit_length=257)
+print("✅ IntHybridArray存储结果：")
+print(f"最大值：{arr_hybrid[0]}")
+print(f"最小值：{arr_hybrid[1]}")
+
+# 2. NumPy：用最大的int64尝试存储（必然失败）
+try:
+    arr_np = np.array([max_num, min_num, 123456], dtype=np.int64)
+    print("\n❌ NumPy存储结果：", arr_np)
+except OverflowError as e:
+    print(f"\n❌ NumPy存储失败：{e}")
 
 ```
 
@@ -316,7 +424,7 @@ toggle_range(arr,0,1)#输出：翻转 {0}-{1} 后：BoolHybridArr(True,False,Tru
 
 ## 版本历史
 
-* **7.8.13**：PyPI上的初始版本，支持基本功能和自动存储优化
+- --7.8.13--：PyPI上的初始版本，支持基本功能和自动存储优化
 * **7.9.0**：添加TruesArray和FalsesArray
 * **7.9.1**：修复介绍的bug，增加copy功能
 * **7.9.2**：新增find()方法
@@ -327,7 +435,7 @@ toggle_range(arr,0,1)#输出：翻转 {0}-{1} 后：BoolHybridArr(True,False,Tru
 * **7.10.4**：修正样例代码中的错误，增加index/rindex的空数组处理
 * **7.10.5**：修复7.10.4版本index/rindex中size没加self的错误
 * **7.10.6**：比7.10.0进一步优化内部储存
-* **7.10.7**：新增arr.memory_usage方法查看是否优化，支持查看内存占用详情及优化建议，配合arr.optimize()实现存储自动调优
+* **7.10.7**：新增arr.memory·_usage方法查看是否优化，支持查看内存占用详情及优化建议，配合arr.optimize()实现存储自动调优
 * **7.10.8**：增加cython加速
 * **7.10.9**：修复之前所有版本的导入问题
 * **7.10.10**：修复unit8溢出问题
@@ -336,7 +444,7 @@ toggle_range(arr,0,1)#输出：翻转 {0}-{1} 后：BoolHybridArr(True,False,Tru
 * **7.10.13**：尝试修复memory_usage方法的错误×3
 * **7.10.14**：尝试修复unit8溢出问题×2
 * **7.10.15**：尝试修复unit8溢出问题×3
-* **7.10.16**：修复unit8溢出问题×4+尝试修复memory_usage方法的错误×4
+* **7.10.16**：修复unit8溢出问题×4+尝试修复memory\_usage方法的错误×4
 * **7.10.17**：尝试修复memory_usage方法的错误×4
 * **7.10.18**：尝试修复memory_usage方法的错误×5
 * **7.10.19**：尝试修复memory_usage方法的错误×6
@@ -358,7 +466,7 @@ toggle_range(arr,0,1)#输出：翻转 {0}-{1} 后：BoolHybridArr(True,False,Tru
 * **7.14.4**：修复in的错误×3
 * **7.14.5**：修复in的错误×4
 * **7.14.6**：优化arr.large的类型
-* **8.0.0**：兼容numpy数组
+- --8.0.0--：兼容numpy数组
 * **8.0.1**：修复8.0.0兼容numpy数组时没有形状参数的问题
 * **8.0.2**：移除bool_hybrid_dtype，改用object
 * **8.1.0**：利用ctypes加速密集部分的一些方法
@@ -370,13 +478,13 @@ toggle_range(arr,0,1)#输出：翻转 {0}-{1} 后：BoolHybridArr(True,False,Tru
 * **8.2.0**：支持哈希
 * **8.2.1**：修复8.2.0版本中的NameError
 * **8.2.2**：修复8.2.1版本中的IndexError
-* **9.0.0**：详情见上
+- --9.0.0--：详情见上
 * **9.0.1**：小更新，优化optimize方法
-* **9.1.0**：新增二维数组的optimize与memory_usage，优化二维数组的位运算，给BHA_Bool新增__rand__、__ror__、__rxor__等等
+* **9.1.0**：新增二维数组的optimize与memory\_usage，优化二维数组的位运算，给BHA\_Bool新增__rand__、**ror**、__rxor__等等
 * **9.1.1**：修复9.1.0版本中的TypeError: unsupported operand type(s) for +: 'int' and 'method'错误
-* **9.1.2**：修复9.1.1版本中的NameError: name 'equivalent_numpy_mem' is not defined错误
-* **9.1.3**：修复9.1.2版本中的NameError: name 'need_optimize' is not defined错误
-* **9.2.0**：详情自己发现，提示：看看iter(arr)的返回值类型、调用一下二维数组的optimize、看看BHA_Bool是不是一个类
+* **9.1.2**：修复9.1.1版本中的NameError: name 'equivalent\_numpy\_mem' is not defined错误
+* **9.1.3**：修复9.1.2版本中的NameError: name 'need\_optimize' is not defined错误
+* **9.2.0**：详情自己发现，提示：看看iter(arr)的返回值类型、调用一下二维数组的optimize、看看BHA\_Bool是不是一个类
 * **9.3.0**：将find()返回值改为BHA_List，将BHA_Iterator变为可复用迭代器
 * **9.4.0**：新增关闭哈希复用功能
 * **9.4.1**：修复了被修改保护和被删除保护的bug
@@ -390,30 +498,99 @@ toggle_range(arr,0,1)#输出：翻转 {0}-{1} 后：BoolHybridArr(True,False,Tru
 * **9.5.2**：修复9.5.1版本中的ResurrectMeta的实例__repr__和__str__的无限递归问题
 * **9.6.0**：新增用装饰器给实例添加动态方法的功能
 * **9.6.1**：修复9.6.0中的参数传递问题
-* **9.6.2**：可以使用BHA_Iterator
+* **9.6.2**：可以使用BHA\_Iterator
 * **9.6.3**：修复常变量删除拦截的逻辑错误
 * **9.6.4**：把常变量删除拦截的逻辑变得更可读
+* **9.6.5**：修复TabError错误
+* **9.6.6**：把常变量删除拦截变得更可读
+* **9.6.7**：修复常变量删除拦截的逻辑错误
+* **9.6.8**：修复常变量删除拦截的逻辑错误
+* **9.6.9**：修复9.6.8中的SyntaxError错误
+* **9.6.10**：修复9.6.9版本中的AttributeError错误
+* **9.6.11**：修复9.6.10版本中的AttributeError: 'dict' object has no attribute '**dict**'. Did you mean: '**dir**'?错误
+* **9.6.12**：修复AttributeError错误
+* **9.6.13**：修复常变量删除拦截的逻辑错误
+* **9.6.14**：修复常变量删除拦截的逻辑错误×2
+* **9.6.15**：修复AttributeError错误
+* **9.6.16**：修复常变量删除拦截的逻辑错误
+* **9.6.17**：类标识错乱修复
+* **9.6.18**：加快了迭代速度
+* **9.6.19**：使用缓存加速
+* **9.6.20**：修复TypeError: unhashable type: 'dict'错误
+* **9.6.21**：修复RecursionError: maximum recursion depth exceeded while calling a Python object错误
+* **9.6.22**：修复RecursionError: maximum recursion depth exceeded while calling a Python object错误×2
+* **9.6.23**：增加了对bool\_hybrid_array.__dict__的防御机制
+* **9.6.23.post1**：修复bool_hybrid_array.__dict__的防御机制的问题
+* **9.6.23.post2**：修复bool_hybrid_array.__dict__的防御机制的问题×2
+* **9.6.23.post3**：修复bool_hybrid_array.__dict__的防御机制的部分逻辑漏洞
+* **9.6.23.post4**：修复bool_hybrid_array.__dict__的防御机制的部分逻辑漏洞×2
+* **9.6.24**：和9.6.23.post4相同，正式版本发布
+* **9.6.25**：增加了对bool\_hybrid\_array里的类的\_\_dict\_\_的防御机制
+* **9.6.25.post1**：修复了“变量名不能以数字开头”的错误
+* **9.6.26**：和9.6.25.post1相同，正式版本发布
+* **9.6.27**：尝试修复T/F相等性判断错误
+* **9.6.27.post1**：尝试修复T/F相等性判断错误×2
+* **9.6.27.post2**：尝试修复T/F相等性判断错误×3
+* **9.6.28**：和* **9.6.27.post2**相同，正式版本发布
+* **9.6.29**：解决了密集区numpy的缓存同步问题和拷贝问题
+* **9.6.30**：增加了”测试代码“文件
+* **9.7.0**：增加了view方法
+* **9.7.1**：修复__array__方法部分的错误
+* **9.7.2**：修复9.7.1版本中numpy 2.0对__array__方法参数的警告
+* **9.7.3**：解决np.array(arr)解释器莫名其妙退出的问题
+* **9.8.0**：增加python 3.9以下的版本泛型、联合类型支持
+* **9.8.1**：让python 3.10+版本泛型、联合类型分别为types.UnionType和types.GenericAlias
+* **9.8.2**：修复9.8.1版本中联合类型返回值的错误
+* **9.9.0**：新增BHA_Function动态创建函数的功能
+* **9.9.1**：增加一下保护字典的保护名单
+* **9.9.2**：加快了any和all的速度
+* **9.9.3**：开放ProtectedBuiltinsDict类型
+* **9.10.0**：新增Ask_BHA和Create_BHA
+* **9.10.1**：修复TypeError: 'BoolHybridArray' object cannot be interpreted as an integer的错误
+* **9.10.2**：解决多补前导零的问题
+* **9.10.3**：解决少补前导零的问题
+* **9.10.4**：新增numba_opt功能
+* **9.10.5**：新增BHA_Opener工具包
+* **9.10.6**：给Ask_BHA新增了mmap优化
+* **9.10.7**：修复了RecursionError: maximum recursion depth exceeded错误
+* **9.10.8**：给Create_BHA新增了mmap优化
+* **9.10.9**：修复9.10.8版本中的NameError错误
+* **9.10.10**：新增int_array模块
+* **9.10.11**：修复NameError: name 'int_array' is not defined. Did you mean: 'bytearray'?的错误
+* **9.10.12**：把find方法的返回值改为IntHybridArray
+* **9.10.13**：给IntHybridArray新增多种列表操作
+* **9.10.14**：修复IntHybridArray中因单个 0 导致所有数字位长被压缩到 1的问题
+* **9.10.15**：修复IntHybridArray变成布尔数组的错误
+* **9.10.16**：新增Python 3.14时的jit优化加速
+* **9.10.17**：给保护字典添加__import__方法，支持from导入
+* **9.10.18**：新增BoolHybridArray的序列化和反序列化支持
+* **9.10.18.post1**：修复TypeError: cannot pickle 'itertools._tee' object错误
+* **9.10.18.post2**：尝试修复“满屏错误”的问题
+* **9.10.18.post3**：尝试修复“满屏错误”的问题×2
+* **9.10.18.post4**：尝试修复“满屏错误”的问题×3
+* **9.10.19**：和9.10.18.post4相同，正式版本发布
 
 
 
 ## **彩蛋：**
 
-- Q：为什么要“密集+稀疏？”
-- A：因为在做线性筛的时候遇到了个问题：密集数组太占内存，稀疏数组跑起来卡，所以就做了这个
-- Q：为什么要“密集numpy.ndarray，稀疏array.array”？
-- A：因为他本来只做线性筛，只修改数组，不insert、pop、remove;稀疏区长度变化平凡，要numpy.ndarray的“**修改就创建新实例**”的话那炸了，所以用array.array,密集区长度不变；所以可以用更高效的numpy.ndarray
-- Q：为什么要有TruesArray/FalsesArray？直接用BoolHybridArr(\[True]\*n)/BoolHybridArr(\[False]\*n)不行吗？
-- A：因为BoolHybridArr(\[True]\*n)在计算\[True]\*n时如果n太大，那么列表的内存会溢出
-- Q：**BoolHybridArr**和**BoolHybridArray**有什么区别？
-- A：BoolHybridArray是本库中的**核心类**，所有函数都是围绕他进行的，但需要split\_index,size,is\_sparse；
-BoolHybridArr是一个**函数**，用于把一个可迭代对象转为BoolHybridArray类
-- Q：为什么不建议把太大的本类型数组打印？
-- A：虽然本类型数组省内存，但字符串不省内存，一个True要4字节，一个False要5字节，连逗号都要占1字节（numpy.ndarray：我都比字符串省内存）
+* Q：为什么要“密集+稀疏？”
+* A：因为在做线性筛的时候遇到了个问题：密集数组太占内存，稀疏数组跑起来卡，所以就做了这个
+* Q：为什么要“密集`numpy.ndarray`，稀疏`array.array`”？
+* A：因为他本来只做线性筛，只修改数组，不`insert`、`pop`、`remove`;稀疏区长度变化平凡，要`numpy.ndarray`的“**修改就创建新实例**”的话那炸了，所以用`array.array`,密集区长度不变；所以可以用更高效的`numpy.ndarray`
+* Q：为什么要有`TruesArray`/`FalsesArray`？直接用`BoolHybridArr([True]*n)`/`BoolHybridArr([False]*n)`不行吗？
+* A：因为`BoolHybridArr([True]*n`)在计算`[True]*n`时如果n太大，那么列表的内存会溢出
+* Q：**`BoolHybridArr`**和**`BoolHybridArray`**有什么区别？
+* A：BoolHybridArray是本库中的**核心类**，所有函数都是围绕他进行的，但需要`split_index`,`size`,`is_sparse`；
+  BoolHybridArr是一个**函数**，用于把一个可迭代对象转为`BoolHybridArray`类
+* Q：为什么不建议把太大的本类型数组打印？
+* A：虽然本类型数组省内存，但字符串不省内存，一个`True`要4字节，一个`False`要5字节，连逗号都要占1字节（`numpy.ndarray`：我都比字符串省内存）
 
 ## 源代码和原理
 
-请见https://code.xdf.cn/freecode/editor?no=80cd07aa023fb2448069e6d8dd50bb5d&type=2&org=code
+请见[来看看我自己的布尔数组吧！](https://code.xdf.cn/freecode/editor?no=80cd07aa023fb2448069e6d8dd50bb5d&type=2&org=code)
 
 ## 许可证
 
 本项目采用**MIT许可证**，详情参见**LICENSE文件**。
+

bool_hybrid_array-9.10.19.dist-info/RECORD

@@ -0,0 +1,10 @@
+bool_hybrid_array/__init__.py,sha256=9iOkIP63rPW5zyyePdZgdMe76_WCN2N-x1wfmN10hM8,1660
+bool_hybrid_array/__main__.py,sha256=3MsUAXMj6Pe1EzP7YreuUePbXZeQvFSCnejnTeS42kU,8324
+bool_hybrid_array/core.py,sha256=plA-XljlNvxmJ1KdH6Y67oLbV2B4xxnqRwj5w7vDl-g,36797
+bool_hybrid_array/秘密.md,sha256=Ii2NvXmv-Ktu04zJsGLcQZvlzT4gOatByE4B2wTK1Ks,48
+bool_hybrid_array/int_array/__init__.py,sha256=EnjBonyL35YKDTtQ2g6tnrf4tTKEt5k-EAEbqLRuptI,8548
+bool_hybrid_array-9.10.19.dist-info/licenses/LICENSE,sha256=Sg4rnGXkBDYkwJCWyxdWp5H60rhVAxpNvFh_l3JWZdY,1070
+bool_hybrid_array-9.10.19.dist-info/METADATA,sha256=E-BM4yONmNrRbjs9eMxxes2kMPTEvcFzgtngnicKBbc,23380
+bool_hybrid_array-9.10.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bool_hybrid_array-9.10.19.dist-info/top_level.txt,sha256=vk-TD77wuVQsN1rJ6uVWZX4sC_wya_WplRDwQKJoBZM,18
+bool_hybrid_array-9.10.19.dist-info/RECORD,,

bool_hybrid_array-9.6.4.dist-info/RECORD

@@ -1,7 +0,0 @@
-bool_hybrid_array/__init__.py,sha256=dvpskBftpmdch7r48IKuOQXtZiBZTCFyAeDRY5U5Nv8,460
-bool_hybrid_array/core.py,sha256=t4lDE8mKecPcGm27WbLdrYE1ZAObptjxzvpHeKnus6M,26982
-bool_hybrid_array-9.6.4.dist-info/licenses/LICENSE,sha256=Sg4rnGXkBDYkwJCWyxdWp5H60rhVAxpNvFh_l3JWZdY,1070
-bool_hybrid_array-9.6.4.dist-info/METADATA,sha256=PmTtG-YOXJfo4NSp84r7bJo9d8wr9zN8kijPhFSwD94,15551
-bool_hybrid_array-9.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bool_hybrid_array-9.6.4.dist-info/top_level.txt,sha256=vk-TD77wuVQsN1rJ6uVWZX4sC_wya_WplRDwQKJoBZM,18
-bool_hybrid_array-9.6.4.dist-info/RECORD,,