Python中内置的数据结构类型详析（内置数据容器）

目录

  • 1. 元组（Tuple）​​
  • 2. 列表（List）​
  • 3. 字典（Dict）
  • 4. 集合（Set）​​
  • 5. 字符串（Str）
  • 6. 队列（Queue）与栈（Stack）​
    • 6.1. 数据访问方式
      • 6.1.1 队列（Queue）
      • 6.1.2 栈（Stack）
    • 6.2. 应用场景
    • 6.3. 实现方式
    • 6.4. 内存结构
    • 6.5. 性能
  • 总结：数据结构对比表

1. 元组（Tuple）​​

元组是一种​​不可变​​的有序序列，用于存储固定数据。适用于需要数据保护或哈希的场景（如字典的键）。

# 1、创建元组
# 可以使用圆括号 () 或者内置的 tuple() 函数来创建元组
empty_tuple = ()  		# 空元组
single_element = (1,)  	# 单元素元组（需逗号）
multi_elements = (1, "a", 3.14)# 使用 tuple() 函数创建元组
from_list = tuple([4, 5, 6]) 	 # 从列表创建元组
from_string = tuple('abc') 		 # 从字符串创建元组 ，输出('a', 'b', 'c')# 2、双向访问与切片
# 元组支持切片操作，用于获取元组的子集
# 切片操作使用 [start:stop:step] 的语法
print(multi_elements[0])       # 输出: 1 
print(multi_elements[-1])      # 输出: 3.14
print(multi_elements[1:3])     # 输出: ('a', 3.14)  
print(multi_elements[0::2])    # 输出：(1, 3.14)  # 3、不可变性示例
try:multi_elements[0] = 10  
except TypeError as e:print(f"错误: {e}")  # 输出: 元组不可修改  # 4、常用方法
# 元组只有两个内置方法：count() 和 index()
# count()：用于返回指定元素在元组中出现的次数
# index()：用于返回指定元素在元组中第一次出现的索引，如果元素不存在则引发 ValueError
count = multi_elements.count(1)      # 统计元素在元组中出现次数  
index = multi_elements.index("a") 	 # 查找元素索引  
print(count, index)  				 # 输出: 1 1  # 5、元组的解包
# 可以将元组中的元素解包到多个变量中
my_tuple = (10, 20, 30)
a, b, c = my_tuple
print(a)  # 输出10
print(b)  # 输出20
print(c)  # 输出30# 6、元组作为函数返回值
# 函数可以返回一个元组，方便同时返回多个值
def get_name_and_age():return 'Alice', 25name, age = get_name_and_age()
print(name)
print(age)# 7、元组的遍历
my_tuple = (1, 2, 3, 4, 5)
for element in my_tuple:print(element)

2. 列表（List）​

列表是​​可变​​的有序集合，支持动态增删改，适合存储动态数据。与元组不同，列表的元素可以被修改、添加或删除。

# 1、创建列表
my_list = [1, "a", 3.14]  
from_range = list(range(3))  # [0, 1, 2]  # 2、访问与切片
my_list = [10, 20, 30, 40, 50]
first_element = my_list[0]		# 访问第一个元素
last_element = my_list[-1]		#访问最后一个元素
subset = my_list[1:3]			# 获取从索引 1 到索引 3（不包含）的元素
every_second = my_list[0::2]	# 获取从索引 0 到末尾，步长为 2 的元素# 3、增删改操作
# 可以使用 append()、extend() 和 insert() 方法来添加元素
# 可以使用 remove()、pop() 和 del 语句来删除元素
my_list = [10, 10, 20, 30, 40, 50]my_list.append(4)          # 末尾添加   
my_list.extend([5, 6])	   # 扩展列表，将另一个可迭代对象的元素添加到列表末尾
my_list.insert(1, 15)	   # 在指定索引位置插入一个元素my_list[1] = 20            # 修改元素  
my_list.remove(20)		   # 删除指定值的第一个匹配项
popped_element = my_list.pop(1)		# 删除指定索引位置的元素，并返回该元素
del my_list[0]             # 删除索引0的元素
print(my_list)             # [20, 30, 40, 50, 4, 5, 6]# 4、切片与遍历
my_list = [10, 10, 20, 30, 40, 50]
print(my_list[::2])        # 输出: [10, 20, 40]  
for idx, val in enumerate(my_list):print(f"索引{idx}: {val}")  # 5、常用方法
# 列表还有 count()、index()、sort()、reverse() 等方法
my_list = [1, 2, 2, 3, 2]
count_2 = my_list.count(2)		# 统计元素 2 出现的次数
index_3 = my_list.index(3)		# 查找元素 3 第一次出现的索引
my_list.sort()					# 对列表进行排序
my_list.reverse()				# 反转列表
print(count_2)	# 3
print(index_3)	# 3
print(my_list) 	# [3, 2, 2, 2, 1]# 6、列表的遍历
my_list = [1, 2, 3, 4, 5]
for element in my_list:print(element)# 7、列表推导式
# 创建一个包含 1 到 5 的平方的列表
# 列表推导式是一种简洁的创建列表的方式
squares = [i ** 2 for i in range(1, 6)]
print(squares)	# [1, 4, 9, 16, 25]

3. 字典（Dict）

字典（dict）是一种无序、可变且以键值对形式存储数据的数据结构。字典是​​键值对​​的无序集合（Python 3.7+ 有序），支持快速查询。

# 1、创建字典
# 可以使用花括号 {} 或者内置的 dict() 函数来创建字典
empty_dict = {}  # 空字典
simple_dict = {'name': 'Alice', 'age': 25}  # 包含键值对的字典
from_tuples = dict([('city', 'New York'), ('country', 'USA')])
from_kwargs = dict(name='Bob', age=30)# 2、访问字典元素
# 可以通过键来访问字典中的值。如果键不存在，直接访问会引发 KeyError
# 解决办法在下段落，此处先不谈
my_dict = {'name': 'Alice', 'age': 25}		
name = my_dict['name']		# 通过键访问值
city = my_dict.get('city')	# 使用 get() 方法访问值，如果键不存在，返回默认值（这里是 None）# 3、增删查改
my_dict = {'name': 'Alice', 'age': 25}	
my_dict['age'] = 26					# 修改已有键的值
my_dict['city'] = 'New York'		# 添加新的键值对
print(my_dict)						# {'name': 'Alice', 'age': 26, 'city': 'New York'}
del my_dict['city']			# 使用 del 语句删除指定键的键值对
age = my_dict.pop('age')	# 使用 pop() 方法删除指定键的键值对，并返回该键对应的值
print(my_dict)				# {'name': 'Alice'}# 4、遍历键值
for key, value in person.items():print(f"{key}: {value}")  # 5、常用方法
# keys()：返回一个包含字典所有键的视图对象。
# values()：返回一个包含字典所有值的视图对象。
# items()：返回一个包含字典所有键值对的视图对象。
# update()：将另一个字典的键值对更新到当前字典中
my_dict = {'name': 'Alice', 'age': 25}
keys = my_dict.keys()			# 获取所有键
values = my_dict.values()		# 获取所有值
items = my_dict.items()			# 获取所有键值对
new_dict = {'city': 'Bei Jing'}	# 更新字典
my_dict.update(new_dict)
print(keys)						# dict_keys(['name', 'age', 'city'])
print(values)					# dict_values(['Alice', 25, 'Bei Jing'])
print(list(values))				# ['Alice', 25, 'Bei Jing']
print(items)					# dict_items([('name', 'Alice'), ('age', 25), ('city', 'Bei Jing')])
print(my_dict)					# {'name': 'Alice', 'age': 25, 'city': 'Bei Jing'}# 6、字典推导式
# 创建一个包含 1 到 5 的平方的字典
squares_dict = {i: i ** 2 for i in range(1, 6)}
print(squares_dict)		# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

在 Python 中，字典（dict）是一种非常常用的数据结构，用于存储键值对。当尝试访问一个不存在的键时，直接使用 dict[key] 会导致 KeyError。为了避免这种情况，可以使用以下几种方法：

  1. 使用 get() 方法
    get() 方法是字典的一个内置方法，它允许你安全地访问字典中的值。如果键不存在，get() 方法会返回一个默认值（通常是 None），而不是抛出错误。
my_dict = {"a": 1, "b": 2}# 使用 get() 方法访问键
value = my_dict.get("a")  # 返回 1
print(value)# 如果键不存在，返回默认值 None
value = my_dict.get("c")  # 返回 None
print(value)# 也可以指定默认值
value = my_dict.get("c", "默认值")  # 返回 "默认值"
print(value)
  1. 使用 defaultdict
    defaultdict 是 collections 模块中的一个类，它继承自普通的字典，但允许你指定一个默认值。当你访问一个不存在的键时，defaultdict 会自动创建一个默认值，并将其与该键关联起来。
from collections import defaultdict# 创建一个 defaultdict，指定默认值为 list
anagram_dict = defaultdict(list)# 添加一些数据
anagram_dict["a"].append("apple")
anagram_dict["b"].append("banana")# 访问一个不存在的键
print(anagram_dict["c"])  # 输出：[]
  1. 使用 setdefault() 方法
    setdefault() 方法也是字典的一个内置方法，它类似于 get()，但会在键不存在时插入一个默认值。
my_dict = {"a": 1, "b": 2}# 使用 setdefault() 方法访问键
value = my_dict.setdefault("a", "默认值")  # 返回 1
print(value)# 如果键不存在，插入默认值
value = my_dict.setdefault("c", "默认值")  # 返回 "默认值"
print(value)print(my_dict)  # 输出：{'a': 1, 'b': 2, 'c': '默认值'}

4. 集合（Set）​​

集合（set）是一种无序且唯一的数据结构，它不允许有重复的元素，常用于去重、成员检测和集合运算（如并集、交集、差集等）。

# 1、创建集合
str = set()					# set() 是创建空集合的唯一方式，str = {}是空字典
my_set = {1, 2, 2, 3}       # 自动去重 → {1, 2, 3}  
from_list = set([3, 4, 5])  
fruits = {'apple', 'banana', 'cherry'}# 2、访问集合元素
# 由于集合是无序的，不能通过索引来访问元素。但可以使用 for 循环遍历集合中的元素，或者使用 in 关键字检查元素是否存在于集合中```python
fruits = {'apple', 'banana', 'cherry'}	# 遍历集合
for fruit in fruits:print(fruit)# 检查元素是否存在
is_apple_in = 'apple' in fruits
print(is_apple_in)		# True# 3、添加元素
# 可以使用 add() 方法向集合中添加单个元素，使用 update() 方法添加多个元素（可以是列表、元组、集合等可迭代对象）
fruits = {'apple', 'banana'}
# 添加单个元素
fruits.add('cherry')
# 添加多个元素
fruits.update(['date', 'elderberry'])
print(fruits)		# {'apple', 'banana', 'cherry', 'elderberry', 'date'}# 4、删除元素
# 可以使用 remove()、discard() 和 pop() 方法来删除集合中的元素
# remove()：如果元素存在，将其从集合中移除；若元素不存在，会引发 KeyError
# discard()：如果元素存在，将其从集合中移除；若元素不存在，不会引发错误
# pop()：随机移除并返回集合中的一个元素，若集合为空，会引发 KeyError
fruits = {'apple', 'banana', 'cherry'}# 使用 remove() 方法删除元素
fruits.remove('apple')# 使用 discard() 方法删除元素
fruits.discard('banana')# 使用 pop() 方法删除元素
popped_fruit = fruits.pop()# 5、集合的常用操作
## 5.1并集：可以使用 | 运算符或 union() 方法实现
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 使用 | 运算符求并集
union_set1 = set1 | set2# 使用 union() 方法求并集
union_set2 = set1.union(set2)print(union_set1)	# {1, 2, 3, 4, 5}
print(union_set2)	# {1, 2, 3, 4, 5}## 5.2交集：可以使用 & 运算符或 intersection() 方法实现
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 使用 & 运算符求交集
intersection_set1 = set1 & set2# 使用 intersection() 方法求交集
intersection_set2 = set1.intersection(set2)print(intersection_set1)	# {3}
print(intersection_set2)	# {3}## 5.3差集：可以使用 - 运算符或 difference() 方法实现
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 使用 - 运算符求差集
difference_set1 = set1 - set2# 使用 difference() 方法求差集
difference_set2 = set1.difference(set2)print(difference_set1)	# {1, 2}
print(difference_set2)	# {1, 2}## 5.4对称差集：可以使用 ^ 运算符或 symmetric_difference() 方法实现
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 使用 ^ 运算符求对称差集
symmetric_difference_set1 = set1 ^ set2# 使用 symmetric_difference() 方法求对称差集
symmetric_difference_set2 = set1.symmetric_difference(set2)print(symmetric_difference_set1)	# {1, 2, 4, 5}
print(symmetric_difference_set2)	# {1, 2, 4, 5}# 6、集合的长度
# 可以使用 len() 函数获取集合中元素的数量
fruits = {'apple', 'banana', 'cherry'}
length = len(fruits)
print(length)	# 3# 7、清空集合
# 可以使用 clear() 方法清空集合中的所有元素
fruits = {'apple', 'banana', 'cherry'}
fruits.clear()
print(fruits)	# set()

5. 字符串（Str）

字符串是​​不可变​​的字符序列，支持文本处理和格式化。

# 创建字符串
s = "Hello, 世界!"  
multiline = """多行  
字符串"""  # 切片与操作
print(s[0:5])              # 输出: Hello  
print(s.upper())           # 转为大写  # 常用方法
words = s.split(",")       # 分割 → ['Hello', ' 世界!']  
joined = '-'.join(words)  # 合并 → "Hello-世界!"  # 格式化
name = "Alice"  
print(f"Name: {name}")     # 输出: Name: Alice

6. 队列（Queue）与栈（Stack）​

​​队列（FIFO）​​：用 deque 实现。
​​栈（LIFO）​​：用列表的 append 和 pop 实现。
队列（Queue）和栈（Stack）是两种常见的数据结构，它们在数据存储和访问方式上有很大的区别。以下是它们的主要区别：

6.1. 数据访问方式

6.1.1 队列（Queue）

特点：先进先出（FIFO，First In First Out）。最早进入队列的元素会最先被移除。
操作：
入队（Enqueue）：在队列的尾部添加一个元素。
出队（Dequeue）：从队列的头部移除一个元素。
查看队首元素（Peek）：查看队列头部的元素，但不移除它。
在这里插入图片描述

6.1.2 栈（Stack）

特点：后进先出（LIFO，Last In First Out）。最后进入栈的元素会最先被移除。
操作：
入栈（Push）：在栈的顶部添加一个元素。
出栈（Pop）：从栈的顶部移除一个元素。
查看栈顶元素（Peek）：查看栈顶的元素，但不移除它。
在这里插入图片描述

# 队列示例
from collections import deque  
queue = deque([1, 2, 3])  
queue.append(4)            # 入队  
print(queue.popleft())     # 出队 → 1  # 栈示例
stack = []  
stack.append(10)          # 入栈  
print(stack.pop())         # 出栈 → 10

6.2. 应用场景

队列（Queue）
任务调度：操作系统中的任务调度，按照任务到达的顺序执行。
消息队列：在多线程或多进程环境中，用于传递消息。
打印队列：打印机按照任务提交的顺序打印文档。
广度优先搜索（BFS）：在图的遍历中，队列用于存储待访问的节点。

栈（Stack）
函数调用：程序运行时，函数调用的上下文（如局部变量、返回地址等）存储在栈中。
表达式求值：计算算术表达式的值，如逆波兰表达式。
括号匹配：检查括号是否正确匹配。
深度优先搜索（DFS）：在图的遍历中，栈用于存储待访问的节点。
撤销操作（Undo）：在软件中实现撤销功能，如文本编辑器中的撤销操作。

6.3. 实现方式

队列（Queue）
Python 实现：可以使用 collections.deque，它是一个双端队列，支持高效的头部和尾部操作。

from collections import dequequeue = deque()
queue.append(1)  # 入队
queue.append(2)
queue.append(3)
print(queue.popleft())  # 出队，输出 1

栈（Stack）
Python 实现：可以使用普通的列表（list），利用 append() 和 pop() 方法来模拟栈的操作。

stack = []
stack.append(1)  # 入栈
stack.append(2)
stack.append(3)
print(stack.pop())  # 出栈，输出 3

6.4. 内存结构

队列（Queue）
队列的元素顺序是固定的，新元素总是添加到尾部，旧元素总是从头部移除。队列的头部和尾部可以动态变化。
队列通常需要维护两个指针（头部指针和尾部指针）来跟踪元素的位置。
栈（Stack）
栈的元素顺序是动态的，新元素总是添加到顶部，旧元素也总是从顶部移除。栈的顶部位置会不断变化。
栈通常只需要维护**一个指针（栈顶指针）**来跟踪元素的位置。

6.5. 性能

队列（Queue）
使用 collections.deque 时，队列的头部和尾部操作（入队、出队）的时间复杂度为 O(1)。
栈（Stack）
使用列表（list）时，栈的入栈和出栈操作的时间复杂度为 O(1)。

总结：数据结构对比表

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/76541.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Socket多路复用网络编程应用总结

Socket多路复用网络编程应用总结

Socket多路复用网络编程应用总结 概述 • 传统I/O模型的局限性：传统阻塞式I/O模型每次仅在一个文件描述符（File Descriptor, FD）上执行I/O操作，导致程序需等待单个操作完成，无法高效处理多连接场景（如高并…
阅读更多...
安卓开发提示Android Gradle plugin错误

安卓开发提示Android Gradle plugin错误

The project is using an incompatible version (AGP 8.9.1) of the Android Gradle plugin. Latest supported version is AGP 8.8.0-alpha05 See Android Studio & AGP compatibility options. 改模块级 build.gradle（如果有独立配置）：…
阅读更多...
【C++初阶】--- vector容器功能模拟实现

【C++初阶】--- vector容器功能模拟实现

1.什么是vector？ 在 C 里，std::vector 是标准模板库（STL）提供的一个非常实用的容器类，它可以看作是动态数组 2.成员变量 iterator _start;：指向 vector 中第一个元素的指针。 iterator _finish;&#x…
阅读更多...
分布式锁在秒杀场景中的Python实现与CAP权衡

分布式锁在秒杀场景中的Python实现与CAP权衡

目录 一、分布式锁的前世今生 二、秒杀系统的 “硬核” 挑战 三、Python 实现分布式锁的 “实战演练” Redis 实现：快准狠 ZooKeeper 实现：稳如老狗 数据库实现：老实本分 四、CAP 理论的 “三角恋” 五、性能优化的 “锦囊妙计” 锁粒度控制：粗细有道 超时机制：别…
阅读更多...
企业级开发SpringBoost玩转Elasticsearch

企业级开发SpringBoost玩转Elasticsearch

案例 Spring Boot 提供了 spring-data-elasticsearch 模块，可以方便地集成 Elasticsearch。 下面我们将详细讲解如何在 Spring Boot 中使用 Elasticsearch 8，并提供示例代码。 1. 添加依赖: 首先，需要在 pom.xml 文件中添加 spring-data-e…
阅读更多...
磐石云智能语音客服系统——技术革新引领服务新体验

磐石云智能语音客服系统——技术革新引领服务新体验

在人工智能技术飞速发展的今天，企业对于智能化客户服务的需求日益增长。磐石云智能语音客服系统凭借其前沿技术架构与深度场景适配能力，正在重新定义人机交互的边界。本文将深入解析该系统如何通过技术创新实现服务效率与体验的双重突破。 一、意图识别…
阅读更多...
OpenGL学习笔记（assimp封装、深度测试、模板测试）

OpenGL学习笔记（assimp封装、深度测试、模板测试）

目录 模型加载Assimp网格模型及导入 深度测试深度值精度深度缓冲的可视化深度冲突 模板测试物体轮廓 GitHub主页：https://github.com/sdpyy1 OpenGL学习仓库:https://github.com/sdpyy1/CppLearn/tree/main/OpenGLtree/main/OpenGL):https://github.com/sdpyy1/CppL…
阅读更多...
通过AWS EKS 生成并部署容器化应用

通过AWS EKS 生成并部署容器化应用

今天给大家分享一个实战例子，如何在EKS上创建容器化应用并通过ALB来发布。先介绍一下几个基本概念： IAM, OpenID Connect (OIDC) 2014 年，AWS Identity and Access Management 增加了使用 OpenID Connect (OIDC) 的联合身份支持。此功能允许…
阅读更多...
入侵检测snort功能概述

入侵检测snort功能概述

1. 数据包嗅探与日志记录 网络流量监控：实时捕获和分析网络数据包（支持以太网、无线等）。 日志记录：将数据包以二进制格式（pcap）或文本格式存储，供后续分析。 2. 协议分析与解码 深度协议解析…
阅读更多...
【Easylive】定时任务-每日数据统计和临时文件清理

【Easylive】定时任务-每日数据统计和临时文件清理

【Easylive】项目常见问题解答（自用&持续更新中…） 汇总版 这个定时任务系统主要包含两个核心功能：每日数据统计和临时文件清理。下面我将详细解析这两个定时任务的实现逻辑和技术要点： Component Slf4j public class SysTas…
阅读更多...
蓝桥杯 15g

蓝桥杯 15g

班级活动 问题描述 小明的老师准备组织一次班级活动。班上一共有 nn 名 (nn 为偶数) 同学，老师想把所有的同学进行分组，每两名同学一组。为了公平，老师给每名同学随机分配了一个 nn 以内的正整数作为 idid，第 ii 名同学的 idid 为…
阅读更多...
如何使用AI辅助开发R语言

如何使用AI辅助开发R语言

R语言是一种用于统计计算和图形生成的编程语言和软件环境，很多学术研究和数据分析的科学家和统计学家更青睐于它。但对与没有编程基础的初学者而言，R语言也是有一定使用难度的。不过现在有了通义灵码辅助编写R语言代码，我们完全可以用自然语言…
阅读更多...
CISCO组建RIP V2路由网络

CISCO组建RIP V2路由网络

1.实验准备： 2.具体配置： 2.1根据分配好的IP地址配置静态IP： 2.1.1PC配置： PC0： PC1： PC2： 2.1.2路由器配置： R0： Router>en Router#conf t Enter configuration…
阅读更多...
React + TipTap 富文本编辑器 实现消息列表展示，类似Slack，Deepseek等对话框功能

React + TipTap 富文本编辑器 实现消息列表展示，类似Slack，Deepseek等对话框功能

经过几天折腾再折腾，弄出来了，弄出来了！！！ 消息展示 在位编辑功能。 两个tiptap实例1个用来展示 消息列表，一个用来在位编辑消息。 tiptap灵活富文本编辑器，拓展性太好了!!! !!! 关键点&#x…
阅读更多...
Ubuntu搭建Pytorch环境

Ubuntu搭建Pytorch环境

Ubuntu搭建Pytorch环境 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 Ubuntu搭建Pytorch环境前言一、Anaconda二、Cuda1.安装流程2、环境变量&#…
阅读更多...
Sping Cloud配置和注册中心

Sping Cloud配置和注册中心

1.Nacos实现原理了解吗？ Nacos是注册中心，主要是帮助我们管理服务列表。Nacos的实现原理大概可以从下面三个方面来讲： 服务注册与发现：当一个服务实例启动时，它会向Nacos Server发送注册请求，将自己的信息…
阅读更多...
C++笔记之父类引用是否可以访问到子类特有的属性？

C++笔记之父类引用是否可以访问到子类特有的属性？

C++笔记之父类引用是否可以访问到子类特有的属性？ code review! 参考笔记 1.C++笔记之在基类和派生类之间进行类型转换的所有方法 文章目录 C++笔记之父类引用是否可以访问到子类特有的属性？1.主要原因2.示例代码3.说明4.如何访问子类特有的属性5.注意事项6.总结在 C++ 中，…
阅读更多...
JavaScript逆向工程：如何判断对称加密与非对称加密

JavaScript逆向工程：如何判断对称加密与非对称加密

在现代Web应用安全分析中，加密算法的识别是JavaScript逆向工程的关键环节。本文将详细介绍如何在逆向工程中判断JavaScript代码使用的是对称加密还是非对称加密。 一、加密算法基础概念 1. 对称加密 (Symmetric Encryption) 特点：加密和解密使用相同的…
阅读更多...
物理备份工具 BRM vs gs_probackup

物理备份工具 BRM vs gs_probackup

什么是BRM 上一篇文章讲了openGauss的物理备份工具gs_probackup，今天来说说BRM备份工具。 BRM备份恢复工具全称为：Backup and Recovery Manager，是MogDB基于opengauss的备份工具 gs_probackup 做了一些封装和优化,面向MogDB数据库实现备份和…
阅读更多...
问问lua怎么写DeepSeek，，，，，

问问lua怎么写DeepSeek，，，，，

很坦白说，这十年，我几乎没办法从互联网找到这个这样的代码，互联网引擎找不到，我也没有很大的“追求”要传承，或者要宣传什么；直到DeepSeek的出现 兄弟，Deepseek现在已经比你更了解你楼下的超市…
阅读更多...
最新文章

Copyright @ 2022~2023