python -【五】数据容器

数据容器

一、列表

列表的循环

name_list = ['张三', '李四', '王五']
print(f'类型是:{type(name_list)}')# while 遍历列表
count = 0
while count < len(name_list):print(f'while 下标为[{count}] 的内容是[{name_list[count]}]')count += 1# for 循环
for name in name_list:print(f'for 值为[{name}]')# for range 循环
for i in range(len(name_list)):print(f'for range 下标为[{i}] 的内容是[{name_list[i]}]')"""
类型是:<class 'list'>
while 下标为[0] 的内容是[张三]
while 下标为[1] 的内容是[李四]
while 下标为[2] 的内容是[王五]
for 值为[张三]
for 值为[李四]
for 值为[王五]
for range 下标为[0] 的内容是[张三]
for range 下标为[1] 的内容是[李四]
for range 下标为[2] 的内容是[王五]
"""

列表的练习题

定义一个列表,内容是 [1,2,3,4,5,6,7,8,9,10]

  • 遍历列表,取出偶数,放入到新的列表对象种
  • 使用 while 和 for 个循环一次
"""
定义一个列表,内容是 [1,2,3,4,5,6,7,8,9,10]
遍历列表,取出偶数,放入到新的列表对象种
使用 while 和 for 个循环一次
"""# 生成原始数据
def generator_origin():origin = []for i in range(1, 11):origin.append(i)print(f'原始数组种的内容是:{origin}')return origin# 使用 for 循环实现
def for_iteration(origin: list):even_number = []for e in origin:if not e % 2:even_number.append(e)print(f'使用for循环得到的偶数列表:{even_number}')# 使用 while 循环实现
def while_iteration(origin: list):even_number = []ct = 0while ct < len(origin):n = origin[ct]if not n % 2:even_number.append(n)ct += 1print(f'使用while循环得到的偶数列表:{even_number}')# 函数汇总入口
def main_func():origin = generator_origin()for_iteration(origin)while_iteration(origin)# main 函数入口
if __name__ == '__main__':main_func()"""
原始数组种的内容是:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
使用for循环得到的偶数列表:[2, 4, 6, 8, 10]
使用while循环得到的偶数列表:[2, 4, 6, 8, 10]
"""

二、元组

元组: 元素一旦被定义完成,不可被修改(抽象理解只读的 list)
数据类型: (元素,元素,元素,元素,元素)

定义元组:
元组字面量:            (元素1, 元素2, 元素3, 元素4)
定义元组变量:        变量名称 = (元素1, 元素2, 元素3, 元素4)
定义空元组方式一: 变量名称 = ()
定义空元组方式二: 变量名称 = tuple()

元组的定义

# 定义元组字面量
(1, 'hello', True)# 定义元组
t1 = (1, 'hello', True)
# 定义空元组
t2 = ()
t3 = tuple()
# 特殊:一个元素的元组定义,必须要加上 ','
# 不加都好
t4 = ('hello')  # str
t5 = ('hello',)  # tupleprint(f't1 的类型{type(t1)}')
print(f't2 的类型{type(t2)}')
print(f't3 的类型{type(t3)}')
print(f't4 的类型{type(t4)}')
print(f't5 的类型{type(t5)}')"""
t1 的类型<class 'tuple'>
t2 的类型<class 'tuple'>
t3 的类型<class 'tuple'>
t4 的类型<class 'str'>
t5 的类型<class 'tuple'>
"""

元组的嵌套

t6 = ((1, 2, 3), (4, 5, 6),)
# 通过下表索引取数据
print(t6[0])
# 从元组中取出 6 元素
print(f'下标为:t6[1][2] 的内容是 {t6[1][2]}')"""
(1, 2, 3)
下标为:t6[1][2] 的内容是 6
"""

元组三个函数的使用 index(), count(), len(tuple)

# index 函数
t7 = ('成都', '重庆', '北京')
idx = t7.index('北京')
print(f'"北京" 的下表是:{idx}')# count 函数
t8 = ('成都', '重庆', '北京', '北京', '北京', '北京', '北京')
ct = t8.count('北京')
print(f'"北京" 在元组中有{ct}个')# len 函数
len_ = len(t8)
print(f'"t8" 元组有 {len_}个元素')"""
"北京" 的下表是:2
"北京" 在元组中有5个
"t8" 元组有 7个元素
"""

元组的遍历

t8 = ('成都', '重庆', '北京', '北京', '北京', '北京', '北京')# while 遍历
i = 0
while i < len(t8):print(f'while 元素:【{t8[i]}】')i += 1# for 遍历
for e in t8:print(f'for 元素:【{e}】')"""
while 元素:【成都】
while 元素:【重庆】
while 元素:【北京】
while 元素:【北京】
while 元素:【北京】
while 元素:【北京】
while 元素:【北京】
for 元素:【成都】
for 元素:【重庆】
for 元素:【北京】
for 元素:【北京】
for 元素:【北京】
for 元素:【北京】
for 元素:【北京】
"""

元组的练习题

定义一个元组,内容是 ('周杰伦', 11, ['football', 'music']) ,记录的是一个学生信息(姓名,年龄,爱好)

请通过元组的功能对其进行:

  • 查询器年龄所在的下表位置
  • 查询学生姓名
  • 删除学生的爱好中的 ‘football’
  • 增加爱好:coding
def tuple_homework():age = 11old_ = 'football'new_ = 'coding't = ('周杰伦', age, [old_, 'music'])# 查询器年龄所在的下表位置age_idx = t.index(age)print(f'年龄[{age}]下标:{age_idx}')# 查询学生姓名print(f'姓名[{t[0]}]')# 删除学生的爱好中的 'football't[2].remove(old_)print(f'删除元素【{old_}】后,元组内容:{t}')# 增加爱好:codingt[2].append(new_)print(f'增加爱好【{new_}】后,元组内容:{t}')tuple_homework()"""
年龄[11]下标:1
姓名[周杰伦]
删除元素【football】后,元组内容:('周杰伦', 11, ['music'])
增加爱好【coding】后,元组内容:('周杰伦', 11, ['music', 'coding'])
"""

三、字符串容器

字符串被看作容器,是因为字符串支持下标索引

字符串的特点:

  • 只能存储字符串
  • 任意长度,却决于内存大小
  • 支持索引下标
  • 允许字符串重复内容
  • while / for 循环都支持
# 字符串的基础操作
my_str = 'hello and world !!!!'# 字符串的替换
new_str = my_str.replace('and', '和')
# 得到一个新的字符串,并没有修改原始的字符串
print(f'修改前:[{my_str}], 修改后:[{new_str}]')# 字符串的切分
strs = my_str.split(' ')
print(f'将 [{my_str}] 切分后:{strs}, 类型:{type(strs)}')# 字符串去前后空格
space = ' im zhang san   '
strip = space.strip()
print(f'规整前:[{space}], 规整后:[{strip}]')# 字符串去前后指定内容
str_ = '211我爱python1111 '
new_str = str_.strip('12 ')   # 1,2,空格  都会移除,而不是一个整体的移除
print(f'规整前:[{str_}], 规整后:[{new_str}]')# 统计某个字符串出现的次数
count = my_str.count('l')
print(f'字符串【{my_str}】内 "l" 出现了 {count} 次')# 统计字符串的长度
len_ = len(my_str)
print(f'字符串【{my_str}】的长度是:{len_}')"""
修改前:[hello and world !!!!], 修改后:[hello 和 world !!!!]
将 [hello and world !!!!] 切分后:['hello', 'and', 'world', '!!!!'], 类型:<class 'list'>
规整前:[ im zhang san   ], 规整后:[im zhang san]
规整前:[211我爱python1111 ], 规整后:[我爱python]
字符串【hello and world !!!!】内 "l" 出现了 3 次
字符串【hello and world !!!!】的长度是:20
"""

四、切片

序列支持切片,即:列表,元组,字符串

切片:从一个序列中,取出一个子序列

语法:序列[起始下标:结束下标:步长]

  • 起始下标:从何处开始,可以留空,留空视为从头开始
  • 结束下标(不含):从何处结束,可以留空,留空视为截取到结尾
  • 步长:
    • 步长 1:一个个取元素
    • 步长 2:没跳过一个元素取
    • 步长 N:每次跳过 N - 1 个元素取
    • 步长为负数:反向取(注意:起始下标和结束下标也要反向标记)

注意:对一个序列切片后,并会影响原始的序列,而是的到一个新的序列

arr = [0, 1, 2, 3, 4, 5, 6, 7]
tup = (0, 1, 2, 3, 4, 5, 6, 7)
str_ = '01234567's1 = arr[1:4]
print(f'list 正向切片 [1:4] 结果为:{s1}')
s2 = arr[3:1:-1]
print(f'list 反向切片 [3:1:-1] 结果为:{s2}')s3 = tup[:]
print(f'tuple 正向切片 [:] 结果为:{s3}')
s4 = tup[7:1:-2]
print(f'tuple 反向切片 [7:1:-2] 结果为:{s4}')s5 = str_[::2]
print(f'str 正向切片 [::2] 结果为:{s5}')
s6 = str_[::-1]
print(f'str 反向切片 [::-1] 结果为:{s6}')"""
list 正向切片 [1:4] 结果为:[1, 2, 3]
list 反向切片 [3:1:-1] 结果为:[3, 2]
tuple 正向切片 [:] 结果为:(0, 1, 2, 3, 4, 5, 6, 7)
tuple 反向切片 [7:1:-2] 结果为:(7, 5, 3)
str 正向切片 [::2] 结果为:0246
str 反向切片 [::-1] 结果为:76543210
"""

切片练习

有一个字符串:“万过薪月,员序程马黑来,nohtyP学”

使用任何学过的方式,得到 “黑马程序员”

content = "万过薪月,员序程马黑来,nohtyP学"
print(content[9:4:-1])"""
黑马程序员
"""

五、Set 集合

Set 集合,元素无序且不允许重复

语法:

  • 变量名 = {元素1,元素2}
  • 变量名 = set()
# 张三重复了,所以元素个数是 3
my_set = {'张三', '李四', '王五', '张三'}
print(f'my_set 的元素个数:{len(my_set)}, 内容:{my_set}, 类型是:{type(my_set)}')# 1. 向集合添加元素
my_set.add('赵六')
print(f'my_set 的元素个数:{len(my_set)}, 内容:{my_set}')# 2. 删除元素
my_set.remove('赵六')
print(f'my_set 的元素个数:{len(my_set)}, 内容:{my_set}')# 3. 随机取出一个元素
ele = my_set.pop()
print(f'随机取出的元素:{ele}, 取出后的set:{my_set}')# 4. 清空集合
my_set.clear()
print(f'清空集合, 清空后的:{my_set}')set_1 = {1, 2, 3}
set_2 = {1, 5, 6}# 5. 取出两个集合的差集,不更新原集合
set_3 = set_1.difference(set_2)
print(f'不更新, 集合1:{set_1}, 集合2:{set_2},差集:{set_3}')
# 取出两个集合的差集,更新原集合
# set_1 集合中的元素会被更新
set_1.difference_update(set_2)
print(f'更新 集合1:{set_1}, 集合2:{set_2}')# 6.
# set_1 被更新了,需要重置里面的数据
set_1 = {1, 2, 3}
# 取出两个集合的并集
set_5 = set_1.intersection(set_2)
print(f'集合1:{set_1}, 集合2:{set_2},并集:{set_5}')# 7. 合并两个集合
set_6 = set_1.union(set_2)
print(f'集合1:{set_1}, 集合2:{set_2},合并:{set_6}')# 8. 统计集合元素数量
size = len(set_1)
print(f'set_1 的元素个数是:{size}')# 9. 集合的遍历
for e in set_1:print(f'元素:{e}')

set集合练习题

信息去重
有如下列表对象:
my_list = ['aaa', 'bbb', 'ccc', 'aaa', 'fff', 'ggg', 'fff', 'ggg', 'best']

请:

  • 定义一个空集合
  • 通过for循环遍历列表
  • 在for循环中将列表的元素添加至集合
  • 最终得到元素去重后的集合对象,并打印输出
my_list = ['aaa', 'bbb', 'ccc', 'aaa', 'fff', 'ggg', 'fff', 'ggg', 'best']my_set = set()
for my in my_list:my_set.add(my)
print(f'去重后的集合:{my_set}, 原集合大小:{len(my_list)}, 去重后大小:{len(my_set)}')

六、字典

字典不允许重复,且无序
字典的定义
字面量:{key: v, key: v}
定义字典变量:my_dict = {key: v, key: v}
定义空字典:my_dict = {}
定义空字典:my_dict = dict()


字典元素的CRUD

"""
字典的增上查改
"""my_dice = {'张三': 77, '李四': 88, '王五': 99}# 新增元素
print('------------新增-------------')
print(f'新增前:{my_dice}')
my_dice['赵六'] = 88
print(f'新增后:{my_dice}')# 更新元素
print('------------更新-------------')
print(f'更新前:{my_dice}')
my_dice['赵六'] = 150
print(f'更新后:{my_dice}')# 删除元素
print('------------删除-------------')
print(f'删除前:{my_dice}')
score = my_dice.pop('赵六')
print(f'删除后:{my_dice}, 被删除的值:{score}')# 获取所有的 key
print('------------获取所有的 key-------------')
keys = my_dice.keys()
print(f'所有的key:{keys}')# 遍历字典: 方式1
print('------------遍历字典:方式1-------------')
keys = my_dice.keys()
for key in keys:print(f'key:{key}, value:{my_dice[key]}')# 遍历字典: 方式2
print('------------遍历字典:方式2-------------')
for k in my_dice:print(f'key:{k}, value:{my_dice[k]}')# 元素数量
print('------------元素数量-------------')
print(f'my_dict 的数量:{len(my_dice)}')# 清空元素
print('------------清空-------------')
print(f'清空前:{my_dice}')
my_dice.clear()
print(f'清空后:{my_dice}')"""
------------新增-------------
新增前:{'张三': 77, '李四': 88, '王五': 99}
新增后:{'张三': 77, '李四': 88, '王五': 99, '赵六': 88}
------------更新-------------
更新前:{'张三': 77, '李四': 88, '王五': 99, '赵六': 88}
更新后:{'张三': 77, '李四': 88, '王五': 99, '赵六': 150}
------------删除-------------
删除前:{'张三': 77, '李四': 88, '王五': 99, '赵六': 150}
删除后:{'张三': 77, '李四': 88, '王五': 99}, 被删除的值:150
------------获取所有的 key-------------
所有的key:dict_keys(['张三', '李四', '王五'])
------------遍历字典:方式1-------------
key:张三, value:77
key:李四, value:88
key:王五, value:99
------------遍历字典:方式2-------------
key:张三, value:77
key:李四, value:88
key:王五, value:99
------------元素数量-------------
my_dict 的数量:3
------------清空-------------
清空前:{'张三': 77, '李四': 88, '王五': 99}
清空后:{}
"""

练习题

练习题:有如下员工信息,请使用字典完成数据的记录
并通过for循环,对所有级别为1级的员工,级别上升1级,薪水增加1000元

姓名  部门  工资  级别
张三  科技  3000  1
李四  市场  5000  2
王五  市场  7000  3
赵六  科技  4000  1
钱七  市场  6000  2

{'姓名': {'部门', '工资', '级别'}
}
emp = {'张三': {'部门': '科技', '工资': 3000, '级别': 1},'李四': {'部门': '市场', '工资': 5000, '级别': 2},'王五': {'部门': '市场', '工资': 7000, '级别': 3},'赵六': {'部门': '科技', '工资': 4000, '级别': 1},'钱七': {'部门': '市场', '工资': 6000, '级别': 2}
}
print(f'全体员工信息如下:\n {emp}')
for em in emp:employ = emp[em]level = employ['级别']if level == 1:employ['级别'] = level + 1employ['工资'] = employ['工资'] + 1000print(f'操作后:\n {emp}')

七、数据容器的通用操作

"""
容器的通用操作
"""my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}# len元素个数
print('-------------元素个数------------')
print(f"列表 元素个数有:{len(my_list)}")
print(f"元组 元素个数有:{len(my_tuple)}")
print(f"字符串元素个数有:{len(my_str)}")
print(f"集合 元素个数有:{len(my_set)}")
print(f"字典 元素个数有:{len(my_dict)}")# max最大元素
print('-------------最大元素------------')
print(f"列表 最大的元素是:{max(my_list)}")
print(f"元组 最大的元素是:{max(my_tuple)}")
print(f"字符串最大的元素是:{max(my_str)}")
print(f"集合 最大的元素是:{max(my_set)}")
print(f"字典 最大的元素是:{max(my_dict)}")# min最小元素
print('-------------最小元素------------')
print(f"列表 最小的元素是:{min(my_list)}")
print(f"元组 最小的元素是:{min(my_tuple)}")
print(f"字符串最小的元素是:{min(my_str)}")
print(f"集合 最小的元素是:{min(my_set)}")
print(f"字典 最小的元素是:{min(my_dict)}")# 容器转列表
print('-------------容器转列表------------')
print(f"列表 转列表:{list(my_list)}")
print(f"元组 转列表:{list(my_tuple)}")
print(f"字符串 转列表:{list(my_str)}")
print(f"集合 转列表:{list(my_set)}")
print(f"字典 转列表:{list(my_dict)}")# 容器转元组
print('-------------容器转元组------------')
print(f"列表 转元组:{tuple(my_list)}")
print(f"元组 转元组:{tuple(my_tuple)}")
print(f"字符串 转元组:{tuple(my_str)}")
print(f"集合 转元组:{tuple(my_set)}")
print(f"字典 转元组:{tuple(my_dict)}")# 容器转字符
print('-------------容器转字符------------')
print(f"列表 转字符串:{str(my_list)}")
print(f"元组 转字符串:{str(my_tuple)}")
print(f"字符串 转字符串:{str(my_str)}")
print(f"集合 转字符串:{str(my_set)}")
print(f"字典 转字符串:{str(my_dict)}")# 容器转集合
print('-------------容器转集合------------')
print(f"列表 转集合:{set(my_list)}")
print(f"元组 转集合:{set(my_tuple)}")
print(f"字符串 转集合:{set(my_str)}")
print(f"集合 转集合:{set(my_set)}")
print(f"字典 转集合:{set(my_dict)}")# 排序
print('-------------正序排序------------')
my_list = [2, 3, 4, 5, 1]
my_tuple = (2, 3, 4, 5, 1)
my_str = "fbcgdae"
my_set = {2, 3, 4, 5, 1}
my_dict = {"key5": 5, "key4": 4, "key1": 1, "key2": 2, "key3": 3}
print(f"列表 正序:{sorted(my_list)}")
print(f"元组 正序:{sorted(my_tuple)}")
print(f"字符 正序:{sorted(my_str)}")
print(f"集合 正序:{sorted(my_set)}")
print(f"字典 正序:{sorted(my_dict)}")
print('-------------倒序排序------------')
print(f"列表 倒序:{sorted(my_list, reverse=True)}")
print(f"元组 倒序:{sorted(my_tuple, reverse=True)}")
print(f"字符 倒序:{sorted(my_str, reverse=True)}")
print(f"集合 倒序:{sorted(my_set, reverse=True)}")
print(f"字典 倒序:{sorted(my_dict, reverse=True)}")

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

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

相关文章

用户接入和认证技术

一、用户接入和认证配置 称为网络接入控制&#xff0c;通过对接入网络的客NAC (Network Admission Control)户端和用户的认证保证网络的安全&#xff0c;是一种“端到端”的安全技术。包括802.1x认证、MAC认证与Portal认证。 二、三种认证方式简介 1、Portal认证 Portal认证通…

Hadoop3:MapReduce之简介、WordCount案例源码阅读、简单功能开发

一、概念 MapReduce是一个 分布式运算程序 的编程框架&#xff0c;是用户开发“基于 Hadoop的数据分析 应用”的核心框架。 MapReduce核心功能是将 用户编写的业务逻辑代码 和 自带默认组件 整合成一个完整的 分布式运算程序 &#xff0c;并发运行在一个 Hadoop集群上。 1、M…

2.1色彩空间

色彩发送器 色彩认知 光源是出生点&#xff0c;光源发射出光线&#xff0c;光线通过直射反射折射等路径最终进入人眼。 但人眼接收到光线后&#xff0c;人眼的细胞产生了一系列化学反应。 由此把产生的信号传入大脑&#xff0c;最终大脑对颜色产生了认知感知。 光的要素 光…

【数据结构】探索树中的奇妙世界

专栏介绍&#xff1a; 哈喽大家好&#xff0c;我是野生的编程萌新&#xff0c;首先感谢大家的观看。数据结构的学习者大多有这样的想法&#xff1a;数据结构很重要&#xff0c;一定要学好&#xff0c;但数据结构比较抽象&#xff0c;有些算法理解起来很困难&#xff0c;学的很累…

C#多线程同步lock、Mutex

C#使用多线程可以通过System.Threading命名空间下的Thread类来实现 lock和Mutex用于实现线程同步的机制&#xff1a; 上代码&#xff1a; class People{public People(int idd){id idd;}public int id;public int age;}class TestHelper{public TestHelper() { }List<Peo…

代码随想录二刷 Day05 | 242.有效的字母异位词,349. 两个数组的交集,202. 快乐数,1. 两数之和,454.四数相加II,383. 赎金信

题目与题解 参考资料&#xff1a;哈希表理论基础 Tips&#xff1a; 一般哈希表都是用来快速判断一个元素是否出现集合里哈希表生成原理&#xff1a;先通过哈希函数将变量映射为hashcode&#xff0c;如果二者hashcode相同&#xff0c;再通过哈希碰撞方法&#xff08;拉链法&…

四川汇聚荣聚荣科技有限公司是正规的吗?

在当今社会&#xff0c;随着科技的飞速发展&#xff0c;越来越多的科技公司如雨后春笋般涌现。然而&#xff0c;在这个信息爆炸的时代&#xff0c;如何判断一家公司是否正规成为了许多人关注的焦点。本文将围绕“四川汇聚荣聚荣科技有限公司是否正规”这一问题展开讨论&#xf…

CSS学习笔记:vw、vh实现移动端适配

移动端适配 移动端即手机端&#xff0c;也称M端 移动端适配&#xff1a;同一套移动端页面在不同屏幕尺寸的手机上可以实现宽度和高度的自适应&#xff0c;也就是页面中元素的宽度和高度可以根据屏幕尺寸的变化等比缩放 之前我在一篇博客中介绍了rem实现移动端适配&#xff0…

CompletableFuture详细讲解

目录 一、基本概念 1.1 异步编程 1.2 CompletableFuture简介 二、创建和完成CompletableFuture 2.1 创建CompletableFuture对象 2.2 手动完成CompletableFuture 2.3 异常完成CompletableFuture 三、异步计算和回调 3.1 异步任务的执行 3.2 处理计算结果 四、组合多个…

Django之文件上传(一)

一、环境搭建 建立项目 django-admin startproject project_demo配置数据库(以MySQL为例) # settings.py DATABASES = {default: {ENGINE: django.db.backends.mysql,NAME: django_file4,USER: root,PASSWORD: 123,HOST: 192.168.31.151,PORT: 3306,} }建立模型 class UploadF…

redis 集群 底层原理以及实操

前言 上篇我们讲解了哨兵集群是怎么回事 也说了对应的leader选举raft算法 也说了对应的slave节点是怎么被leader提拔的 主要是比较优先级 比较同步偏移量 比较runid等等 今天我们再说说,其实哨兵也有很多缺点 虽然在master挂了之后能很快帮我们选举出新的master 但是对于单个ma…

【Spring Cloud】分布式配置

目录 未来的开发场景为什么需要配置中心配置实时生效配置管理流程 开源配置中心基本介绍DisconfSpring Cloud ConfigApolloNacos Spring Cloud Config介绍配置管理工具体系 案例需求编写 Config Server1.创建配置文件2.创建项目3.添加依赖4.添加注解5.修改配置文件application.…

Python OCR 文字识别使用模型:读光-文字识别-行识别模型-中英-通用领域

介绍 什么是OCR&#xff1f; OCR是“Optical Character Recognition”的缩写&#xff0c;中文意为“光学字符识别”。它是一种技术&#xff0c;可以识别和转换打印在纸张或图像上的文字和字符为机器可处理的格式&#xff0c;如计算机文本文件。通过使用OCR技术&#xff0c;可…

在iPhone上恢复误删除的微信聊天记录

想知道是否可以恢复 微信iPhone 上误删除的消息&#xff1f;继续阅读以获取所有相关问题的答案。 过去几年&#xff0c;像微信这样的社交媒体应用为我们的生活增添了不少乐趣。它们让我们可以随时随地与朋友和家人保持联系。 微信是一个简化且热门的通信平台&#xff0c;它允…

数据结构 | 详解二叉树——堆与堆排序

&#x1f95d;堆 堆总是一棵完全二叉树。 大堆&#xff1a;父节点总是大于子节点。 小堆&#xff1a;父节点总是小于子节点。 注意&#xff1a;1.同一个节点下的两个子节点并无要求先后顺序。 2.堆可以是无序的。 &#x1f349;堆的实现 &#x1f334;深度剖析 1.父节点和子…

QT截图程序,可多屏幕截图二,增加调整截图区域功能

上一篇QT截图程序&#xff0c;可多屏幕截图只是实现了最基本的截图功能&#xff0c;虽然能用但是缺点也有&#xff0c;没办法更改选中的区域&#xff0c;这在实际使用时不太方便。这篇增加了这个功能。先看看效果。 实现代码为&#xff1a; 头文件 #ifndef MASKWIDGET_H #de…

Matlab|基于PMU相量测量单元进行电力系统电压幅值和相角状态估计

主要内容 程序采用三种方法对14节点和30节点电力系统状态进行评估&#xff1a; ①PMU同步相量测量单元结合加权最小二乘法&#xff08;WLS&#xff09;分析电力系统的电压幅值和相角状态&#xff1b; ②并采用牛顿-拉夫逊方法进行系统潮流计算&#xff0c;结果作为理论分…

LLAMA3==shenzhi-wang/Llama3-8B-Chinese-Chat。windows安装不使用ollama

创建环境&#xff1a; conda create -n llama3_env python3.10 conda activate llama3_env conda install pytorch torchvision torchaudio cudatoolkit11.7 -c pytorch 安装Hugging Face的Transformers库&#xff1a; pip install transformers sentencepiece 下载模型 ht…

开源一个工厂常用的LIMS系统

Senaite是一款强大且可靠的基于Web的LIMS/LIS系统&#xff0c;采用Python编写&#xff0c;构建在Plone CMS基础架构之上。该系统处于积极开发阶段&#xff0c;在灵活的定制空间中为开发人员提供了丰富的功能。其中&#xff0c;Senaite在处理REST的JSON API上做得出色&#xff0…

python -【二】判断语句

判断语句 一、 布尔类型 True&#xff1a;真(1)False&#xff1a;假(0) 比较运算符 运算符实例1 1 True!1 ! 1 Flase<1 < 1 Flse>1 > 1 Flse<1 < 1 True>1 > 1 True b1 True b2 False print(f"b1值是{b1},类型是{type(b1)}") print(…