mlymath 0.3.0b1__tar.gz → 0.4.0b2__tar.gz

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.2
 Name: mlymath
-Version: 0.3.0b1
+Version: 0.4.0b2
 Summary: 一个用于数学计算的Python库
 Author: mly
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Dynamic: author
 Dynamic: classifier
@@ -23,9 +23,7 @@ Dynamic: summary
     - is_prime(n) -> bool: 判断一个整数是否为素数
     - comb(n: int, k: int) -> int: 计算组合数 C(n, k)
     - pow(x, y): 快速计算 x 的 y 次幂
-    - sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串
-    - sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串
-    - sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串
+
     - fib_list(n) -> list: 生成包含前 N 项的斐波那契数列
     - fib(n) -> int: 返回第 N 项的斐波那契数
     - pell_list(n) -> list: 生成包含前 N 项的佩尔数列
@@ -46,10 +44,16 @@ Dynamic: summary
     - min(\*nums, n): 找到多个数中第 N 小的数, 输入n时请注意使用n = [num]
     - list_min_index(nums, n): 找到数组中第 N 小的数的索引
     - min_index(\*nums, n): 找到多个数中第 N 小的数的索引, 输入n时请注意使用n = [num]
+    - math_help() -> None: 显示math帮助信息
+- mlymath.RSA RSA
     - get_rsa_keys(p: int, q: int) -> Tuple[Tuple[int, int], Tuple[int, int]]: 生成 RSA 公钥和私钥
     - rsa_encrypt(public_key: Tuple[int, int], plaintext: int) -> int: 使用 RSA 公钥加密数据
     - rsa_decrypt(private_key: Tuple[int, int], ciphertext: int) -> int: 使用 RSA 私钥解密数据
-    - math_help() -> None: 显示math帮助信息
+    - RSA_help(): 显示帮助信息
+- mlymath.hash 哈希模块
+    - sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串
+    - sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串
+    - sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串
 - mlymath.sort 排序模块
     - quick_sort: 使用快速排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）
     - shell_sort: 使用希尔排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）
@@ -83,8 +87,17 @@ Dynamic: summary
 	- mod7(n): 判断 n 是否能被 7 整除。
 	- mod8(n): 判断 n 是否能被 8 整除。
 	- mod9(n): 判断 n 是否能被 9 整除。
+- mlymath.random 随机数模块
+    - randint(a, b): 返回[a,b]之间的随机整数
+    - randfloat(a, b): 返回[a,b]之间的随机浮点数
+    - randlst(a, b, n): 返回[a,b]之间的n个随机整数
+    - randls_float(a, b, n): 返回[a,b]之间的n个随机浮点数
+    - randint_notsame(a, b): 返回[a,b]之间的不重复随机整数
+    - randfloat_notsame(a, b): 返回[a,b]之间的不重复随机浮点数
+    - randlst_notsame(a, b, n): 返回[a,b]之间的n个不重复随机整数
+    - randls_float_notsame(a, b, n): 返回[a,b]之间的n个不重复随机浮点数
+    - random_help(): 显示随机数模块的帮助信息
+
 #### mly万岁！！！🎉
 #### mly万岁！！！🎉
 #### mly万岁！！！🎉
-
-

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/README.md

@@ -6,9 +6,7 @@
     - is_prime(n) -> bool: 判断一个整数是否为素数
     - comb(n: int, k: int) -> int: 计算组合数 C(n, k)
     - pow(x, y): 快速计算 x 的 y 次幂
-    - sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串
-    - sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串
-    - sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串
+
     - fib_list(n) -> list: 生成包含前 N 项的斐波那契数列
     - fib(n) -> int: 返回第 N 项的斐波那契数
     - pell_list(n) -> list: 生成包含前 N 项的佩尔数列
@@ -29,10 +27,16 @@
     - min(\*nums, n): 找到多个数中第 N 小的数, 输入n时请注意使用n = [num]
     - list_min_index(nums, n): 找到数组中第 N 小的数的索引
     - min_index(\*nums, n): 找到多个数中第 N 小的数的索引, 输入n时请注意使用n = [num]
+    - math_help() -> None: 显示math帮助信息
+- mlymath.RSA RSA
     - get_rsa_keys(p: int, q: int) -> Tuple[Tuple[int, int], Tuple[int, int]]: 生成 RSA 公钥和私钥
     - rsa_encrypt(public_key: Tuple[int, int], plaintext: int) -> int: 使用 RSA 公钥加密数据
     - rsa_decrypt(private_key: Tuple[int, int], ciphertext: int) -> int: 使用 RSA 私钥解密数据
-    - math_help() -> None: 显示math帮助信息
+    - RSA_help(): 显示帮助信息
+- mlymath.hash 哈希模块
+    - sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串
+    - sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串
+    - sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串
 - mlymath.sort 排序模块
     - quick_sort: 使用快速排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）
     - shell_sort: 使用希尔排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）
@@ -66,8 +70,17 @@
 	- mod7(n): 判断 n 是否能被 7 整除。
 	- mod8(n): 判断 n 是否能被 8 整除。
 	- mod9(n): 判断 n 是否能被 9 整除。
+- mlymath.random 随机数模块
+    - randint(a, b): 返回[a,b]之间的随机整数
+    - randfloat(a, b): 返回[a,b]之间的随机浮点数
+    - randlst(a, b, n): 返回[a,b]之间的n个随机整数
+    - randls_float(a, b, n): 返回[a,b]之间的n个随机浮点数
+    - randint_notsame(a, b): 返回[a,b]之间的不重复随机整数
+    - randfloat_notsame(a, b): 返回[a,b]之间的不重复随机浮点数
+    - randlst_notsame(a, b, n): 返回[a,b]之间的n个不重复随机整数
+    - randls_float_notsame(a, b, n): 返回[a,b]之间的n个不重复随机浮点数
+    - random_help(): 显示随机数模块的帮助信息
+
 #### mly万岁！！！🎉
 #### mly万岁！！！🎉
-#### mly万岁！！！🎉
-
-
+#### mly万岁！！！🎉

mlymath-0.4.0b2/RSA/RSA.py

@@ -0,0 +1,74 @@
+import hashlib
+import random
+from typing import Tuple
+
+def get_rsa_key(p: int, q: int) -> Tuple[Tuple[int, int], Tuple[int, int]]:
+    """
+    生成 RSA 公钥和私钥。
+    :param p: 第一个大素数
+    :param q: 第二个大素数
+    :return: 公钥 (e, n) 和私钥 (d, n)
+    """
+    n = p * q
+    phi = (p - 1) * (q - 1)
+
+    def multiplicative_inverse(e: int, phi: int) -> int:
+        d = 0
+        x1 = 0
+        x2 = 1
+        y1 = 1
+        temp_phi = phi
+        
+        while e > 0:
+            temp1 = temp_phi // e
+            temp2 = temp_phi - temp1 * e
+            temp_phi = e
+            e = temp2
+            
+            x = x2 - temp1 * x1
+            y = d - temp1 * y1
+            
+            x2 = x1
+            x1 = x
+            d = y1
+            y1 = y
+        
+        if temp_phi == 1:
+            return d + phi
+
+    e = random.randint(1, phi)
+    from mlymath.math import gcd
+    while gcd(e, phi) != 1:  # 直接调用模块级 gcd 函数
+        e = random.randint(1, phi)
+    
+    d = multiplicative_inverse(e, phi)
+    return (e, n), (d, n)
+
+def rsa_encrypt(public_key: Tuple[int, int], plaintext: int) -> int:
+    """
+    使用 RSA 公钥加密数据。
+    :param public_key: 公钥 (e, n)
+    :param plaintext: 明文数据
+    :return: 密文数据
+    """
+    e, n = public_key
+    return pow(plaintext, e, n)
+
+def rsa_decrypt(private_key: Tuple[int, int], ciphertext: int) -> int:
+    """
+    使用 RSA 私钥解密数据。
+    :param private_key: 私钥 (d, n)
+    :param ciphertext: 密文数据
+    :return: 明文数据
+    """
+    d, n = private_key
+    return pow(ciphertext, d, n)
+
+def RSA_help():
+    """提供模块帮助信息"""
+    print("以下是可用的函数:")
+    print("- get_rsa_keys(p: int, q: int) -> Tuple[Tuple[int, int], Tuple[int, int]]: 生成 RSA 公钥和私钥")
+    print("- rsa_encrypt(public_key: Tuple[int, int], plaintext: int) -> int: 使用 RSA 公钥加密数据")
+    print("- rsa_decrypt(private_key: Tuple[int, int], ciphertext: int) -> int: 使用 RSA 私钥解密数据")
+    print("- RSA_help() -> None: 显示帮助信息")
+

mlymath-0.4.0b2/RSA/__init__.py

@@ -0,0 +1,13 @@
+from .RSA import (
+    get_rsa_key,
+    rsa_encrypt,
+    rsa_decrypt,
+    RSA_help
+)
+
+__all__ = [
+    'get_rsa_key',
+    'rsa_encrypt',
+    'rsa_decrypt',
+    'RSA_help'
+]

mlymath-0.4.0b2/_random/__init__.py

@@ -0,0 +1,23 @@
+from ._random import (
+    randint, 
+    randfloat, 
+    randlst, 
+    randls_float,
+    randint_notsame, 
+    randfloat_notsame, 
+    randlst_notsame, 
+    randls_float_notsame,
+    random_help
+)
+
+__all__ = [
+    "randint", 
+    "randfloat", 
+    "randlst", 
+    "randls_float",
+    "randint_notsame", 
+    "randfloat_notsame", 
+    "randlst_notsame", 
+    "randls_float_notsame",
+    "random_help"
+]

mlymath-0.4.0b2/_random/_random.py

@@ -0,0 +1,91 @@
+from random import randint, uniform, sample, shuffle, getrandbits
+
+def randint(a, b):
+    """
+    返回[a,b]之间的随机整数
+    a <= return <= b
+    """
+    return randint(a, b)  # 使用标准库实现
+
+def randfloat(a, b):
+    """
+    返回[a,b]之间的随机浮点数
+    a <= return <= b
+    """
+    # 使用标准random生成浮点数
+    return a + (b - a) * (getrandbits(32) / (2**32 - 1))  # 替换randbits方法
+
+def randlst(a, b, n):
+    """
+    返回[a,b]之间的n个随机整数
+    """
+    return [randint(a, b) for _ in range(n)]  # 使用标准randint
+
+def randls_float(a, b, n):
+    """
+    返回[a,b]之间的n个随机浮点数
+    """
+    step = (b - a) / 1000  
+    float_values = [a + i * step for i in range(1000)]
+    # 使用标准shuffle
+    shuffle(float_values)  # 替换SystemRandom().shuffle
+    return float_values[:n]
+
+def randint_notsame(a, b):
+    """
+    返回[a,b]之间的不重复随机整数
+    a <= return <= b
+    """
+    try:
+        return randint(a, b)  # 替换randbelow为randint
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def randfloat_notsame(a, b):
+    """
+    返回[a,b]之间的不重复随机浮点数
+    a <= return <= b
+    """
+    try:
+        # 替换_secrets相关实现
+        return uniform(a, b)  # 直接使用标准库uniform
+    except ValueError:
+        return "Error: Insufficient elements to generate unique random float."
+
+def randlst_notsame(a, b, n):
+    """
+    返回[a,b]之间的n个不重复随机整数
+    """
+    try:
+        population = list(range(a, b + 1))
+        # 使用标准sample方法
+        return sample(population, min(n, len(population)))  # 替换pop+randbelow逻辑
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def randls_float_notsame(a, b, n):
+    """
+    返回[a,b]之间的n个不重复随机浮点数
+    """
+    # 简化实现
+    if n > 1000:
+        return f"Error: Cannot generate more than 1000 unique floats between {a} and {b}"
+    
+    # 使用标准库生成并打乱
+    step = (b - a) / 1000  
+    float_values = [a + i * step for i in range(1000)]
+    shuffle(float_values)  # 替换_secrets shuffle
+    return float_values[:n]
+
+def random_help():
+    """提供模块帮助信息"""
+    print("以下是可用的函数:")
+    print("- randint(a, b): 返回[a,b]之间的随机整数")
+    print("- randfloat(a, b): 返回[a,b]之间的随机浮点数")
+    print("- randlst(a, b, n): 返回[a,b]之间的n个随机整数")
+    print("- randls_float(a, b, n): 返回[a,b]之间的n个随机浮点数")
+    print("- randint_notsame(a, b): 返回[a,b]之间的不重复随机整数")
+    print("- randfloat_notsame(a, b): 返回[a,b]之间的不重复随机浮点数")
+    print("- randlst_notsame(a, b, n): 返回[a,b]之间的n个不重复随机整数")
+    print("- randls_float_notsame(a, b, n): 返回[a,b]之间的n个不重复随机浮点数")
+    print("- random_help(): 显示帮助信息")

mlymath-0.4.0b2/hsah/__init__.py

@@ -0,0 +1,13 @@
+from .hash import (
+    sha256,
+    sha3_256,
+    sha3_512,
+    hash_help
+)
+
+__all__ = [
+    'sha256',
+    'sha3_256',
+    'sha3_512',
+    'hash_help'
+]

mlymath-0.4.0b2/hsah/hash.py

@@ -0,0 +1,37 @@
+import hashlib
+
+def sha3_256(input_string: str) -> str:
+    """
+    使用 SHA3-256 算法加密字符串。
+    :param input_string: 待加密的字符串
+    :return: 加密后的十六进制字符串
+    """
+    sha3_256_hash = hashlib.sha3_256(input_string.encode()).hexdigest()
+    return sha3_256_hash
+
+def sha3_512(input_string: str) -> str:
+    """
+    使用 SHA3-512 算法加密字符串。
+    :param input_string: 待加密的字符串
+    :return: 加密后的十六进制字符串
+    """
+    sha3_512_hash = hashlib.sha3_512(input_string.encode()).hexdigest()
+    return sha3_512_hash
+
+
+def sha256(input_string: str) -> str:
+    """
+    使用 SHA-256 算法加密字符串。
+    :param input_string: 待加密的字符串
+    :return: 加密后的十六进制字符串
+    """
+    sha256_hash = hashlib.sha256(input_string.encode()).hexdigest()
+    return sha256_hash
+
+def hash_help():
+    """提供模块帮助信息"""
+    print("以下是可用的函数:")
+    print("- sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串")
+    print("- sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串")
+    print("- sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串")
+    print("- hash_help(): 提供模块帮助信息")

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/math/__init__.py

@@ -1,7 +1,4 @@
 from .math import (
-    sha3_256,
-    sha3_512,
-    sha256,
     gcd,
     lcm,
     is_prime,
@@ -27,16 +24,10 @@ from .math import (
     max_index,
     list_min_index,
     min_index,
-    get_rsa_key,
-    rsa_encrypt,
-    rsa_decrypt,
     math_help
 )
 
 __all__ = [
-    'sha3_256',
-    'sha3_512',
-    'sha256',
     'gcd',
     'lcm',
     'is_prime',
@@ -62,8 +53,5 @@ __all__ = [
     'max_index',
     'list_min_index',
     'min_index',
-    'get_rsa_key',
-    'rsa_encrypt',
-    'rsa_decrypt',
     'math_help'
 ]

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/math/math.py

@@ -1,97 +1,5 @@
-import hashlib
-import random
 from typing import Tuple
 
-def get_rsa_key(p: int, q: int) -> Tuple[Tuple[int, int], Tuple[int, int]]:
-    """
-    生成 RSA 公钥和私钥。
-    :param p: 第一个大素数
-    :param q: 第二个大素数
-    :return: 公钥 (e, n) 和私钥 (d, n)
-    """
-    n = p * q
-    phi = (p - 1) * (q - 1)
-
-    def multiplicative_inverse(e: int, phi: int) -> int:
-        d = 0
-        x1 = 0
-        x2 = 1
-        y1 = 1
-        temp_phi = phi
-        
-        while e > 0:
-            temp1 = temp_phi // e
-            temp2 = temp_phi - temp1 * e
-            temp_phi = e
-            e = temp2
-            
-            x = x2 - temp1 * x1
-            y = d - temp1 * y1
-            
-            x2 = x1
-            x1 = x
-            d = y1
-            y1 = y
-        
-        if temp_phi == 1:
-            return d + phi
-
-    e = random.randint(1, phi)
-    while gcd(e, phi) != 1:  # 直接调用模块级 gcd 函数
-        e = random.randint(1, phi)
-    
-    d = multiplicative_inverse(e, phi)
-    return (e, n), (d, n)
-
-def rsa_encrypt(public_key: Tuple[int, int], plaintext: int) -> int:
-    """
-    使用 RSA 公钥加密数据。
-    :param public_key: 公钥 (e, n)
-    :param plaintext: 明文数据
-    :return: 密文数据
-    """
-    e, n = public_key
-    return pow(plaintext, e, n)
-
-def rsa_decrypt(private_key: Tuple[int, int], ciphertext: int) -> int:
-    """
-    使用 RSA 私钥解密数据。
-    :param private_key: 私钥 (d, n)
-    :param ciphertext: 密文数据
-    :return: 明文数据
-    """
-    d, n = private_key
-    return pow(ciphertext, d, n)
-
-def sha3_256(input_string: str) -> str:
-    """
-    使用 SHA3-256 算法加密字符串。
-    :param input_string: 待加密的字符串
-    :return: 加密后的十六进制字符串
-    """
-    sha3_256_hash = hashlib.sha3_256(input_string.encode()).hexdigest()
-    return sha3_256_hash
-
-def sha3_512(input_string: str) -> str:
-    """
-    使用 SHA3-512 算法加密字符串。
-    :param input_string: 待加密的字符串
-    :return: 加密后的十六进制字符串
-    """
-    sha3_512_hash = hashlib.sha3_512(input_string.encode()).hexdigest()
-    return sha3_512_hash
-
-
-def sha256(input_string: str) -> str:
-    """
-    使用 SHA-256 算法加密字符串。
-    :param input_string: 待加密的字符串
-    :return: 加密后的十六进制字符串
-    """
-    sha256_hash = hashlib.sha256(input_string.encode()).hexdigest()
-    return sha256_hash
-
-
 def gcd(*nums: int) -> int:
     """优化后：移除冗余操作"""
     from math import gcd as _gcd  # 模块级导入（关键）
@@ -414,16 +322,12 @@ def min_index(*nums, n):
     return sorted_indices[n - 1]
 
 def math_help():
-    """提供模块帮助信息"""
-    print("以下是可用的函数:")
+    # 显示帮助信息
     print("- gcd(*nums: int) -> int: 计算多个整数的最大公约数")
     print("- lcm(*nums: int) -> int: 计算多个整数的最小公倍数")
     print("- is_prime(n) -> bool: 判断一个整数是否为素数")
     print("- comb(n: int, k: int) -> int: 计算组合数 C(n, k)")
     print("- pow(x, y): 快速计算 x 的 y 次幂")
-    print("- sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串")
-    print("- sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串")
-    print("- sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串")
     print("- fib_list(n) -> list: 生成包含前 N 项的斐波那契数列")
     print("- fib(n) -> int: 返回第 N 项的斐波那契数")
     print("- pell_list(n) -> list: 生成包含前 N 项的佩尔数列")

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/mlymath.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.2
 Name: mlymath
-Version: 0.3.0b1
+Version: 0.4.0b2
 Summary: 一个用于数学计算的Python库
 Author: mly
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Dynamic: author
 Dynamic: classifier
@@ -23,9 +23,7 @@ Dynamic: summary
     - is_prime(n) -> bool: 判断一个整数是否为素数
     - comb(n: int, k: int) -> int: 计算组合数 C(n, k)
     - pow(x, y): 快速计算 x 的 y 次幂
-    - sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串
-    - sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串
-    - sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串
+
     - fib_list(n) -> list: 生成包含前 N 项的斐波那契数列
     - fib(n) -> int: 返回第 N 项的斐波那契数
     - pell_list(n) -> list: 生成包含前 N 项的佩尔数列
@@ -46,10 +44,16 @@ Dynamic: summary
     - min(\*nums, n): 找到多个数中第 N 小的数, 输入n时请注意使用n = [num]
     - list_min_index(nums, n): 找到数组中第 N 小的数的索引
     - min_index(\*nums, n): 找到多个数中第 N 小的数的索引, 输入n时请注意使用n = [num]
+    - math_help() -> None: 显示math帮助信息
+- mlymath.RSA RSA
     - get_rsa_keys(p: int, q: int) -> Tuple[Tuple[int, int], Tuple[int, int]]: 生成 RSA 公钥和私钥
     - rsa_encrypt(public_key: Tuple[int, int], plaintext: int) -> int: 使用 RSA 公钥加密数据
     - rsa_decrypt(private_key: Tuple[int, int], ciphertext: int) -> int: 使用 RSA 私钥解密数据
-    - math_help() -> None: 显示math帮助信息
+    - RSA_help(): 显示帮助信息
+- mlymath.hash 哈希模块
+    - sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串
+    - sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串
+    - sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串
 - mlymath.sort 排序模块
     - quick_sort: 使用快速排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）
     - shell_sort: 使用希尔排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）
@@ -83,8 +87,17 @@ Dynamic: summary
 	- mod7(n): 判断 n 是否能被 7 整除。
 	- mod8(n): 判断 n 是否能被 8 整除。
 	- mod9(n): 判断 n 是否能被 9 整除。
+- mlymath.random 随机数模块
+    - randint(a, b): 返回[a,b]之间的随机整数
+    - randfloat(a, b): 返回[a,b]之间的随机浮点数
+    - randlst(a, b, n): 返回[a,b]之间的n个随机整数
+    - randls_float(a, b, n): 返回[a,b]之间的n个随机浮点数
+    - randint_notsame(a, b): 返回[a,b]之间的不重复随机整数
+    - randfloat_notsame(a, b): 返回[a,b]之间的不重复随机浮点数
+    - randlst_notsame(a, b, n): 返回[a,b]之间的n个不重复随机整数
+    - randls_float_notsame(a, b, n): 返回[a,b]之间的n个不重复随机浮点数
+    - random_help(): 显示随机数模块的帮助信息
+
 #### mly万岁！！！🎉
 #### mly万岁！！！🎉
 #### mly万岁！！！🎉
-
-

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/mlymath.egg-info/SOURCES.txt

@@ -1,5 +1,11 @@
 README.md
 setup.py
+RSA/RSA.py
+RSA/__init__.py
+_random/__init__.py
+_random/_random.py
+hsah/__init__.py
+hsah/hash.py
 math/__init__.py
 math/math.py
 mlymath.egg-info/PKG-INFO

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/mlymath.egg-info/top_level.txt

@@ -1,3 +1,6 @@
+RSA
+_random
+hsah
 math
 mod
 morse

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/mod/mod.py

@@ -26,11 +26,12 @@ def mod9(n):
 
 def mod_help():
     print("以下是可用的函数：")
-    print("- mod2(n): 判断 n 是否能被 2 整除。")
-    print("- mod3(n): 判断 n 是否能被 3 整除。")
-    print("- mod4(n): 判断 n 是否能被 4 整除。")
-    print("- mod5(n): 判断 n 是否能被 5 整除。")
-    print("- mod6(n): 判断 n 是否能被 6 整除。")
-    print("- mod7(n): 判断 n 是否能被 7 整除。")
-    print("- mod8(n): 判断 n 是否能被 8 整除。")
-    print("- mod9(n): 判断 n 是否能被 9 整除。")
+    print("- mod2(n): 判断 n 是否能被 2 整除")
+    print("- mod3(n): 判断 n 是否能被 3 整除")
+    print("- mod4(n): 判断 n 是否能被 4 整除")
+    print("- mod5(n): 判断 n 是否能被 5 整除")
+    print("- mod6(n): 判断 n 是否能被 6 整除")
+    print("- mod7(n): 判断 n 是否能被 7 整除")
+    print("- mod8(n): 判断 n 是否能被 8 整除")
+    print("- mod9(n): 判断 n 是否能被 9 整除")
+    print("- mod_help(): 显示所有可用的函数")

{mlymath-0.3.0b1 → mlymath-0.4.0b2}/setup.py

@@ -5,7 +5,7 @@ with open('README.md', 'r', encoding='utf-8') as fh:
 
 setup(
     name='mlymath',
-    version='0.3.0-beta1',
+    version='0.4.0-beta2',
     packages=find_packages(),
     install_requires=[
 
@@ -20,5 +20,5 @@ setup(
         'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
     ],
-    python_requires='>=3.6',
+    python_requires='>=3.12',
 )