Python数据容器（列表list、元组tuple、字符串str、字典dict、集合set）详解

一、数据容器概念

相关介绍：

  • 一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素。每一个元素，可以是任意类型的数据
  • 分为五类：列表[list]、元组(tuple)、字符串(str)、集合{set}、字典{dict}

相应区别：

列表元祖字符串集合字典
<元素数量>多个多个多个多个多个
<元素类型>任意任意仅字符任意key(除字典外任意):value(任意)
<下表索引>支持支持支持不支持不支持
<重复元素>支持支持支持不支持不支持
<可否修改>支持不支持不支持支持支持
<数据有序>是是是否否

相应特点：

都支持for循环，集合、字典不支持（无法下标索引）

  • 列表： 有一批数据，需要可修改、可重复的存储场景
  • 元祖： 有一批数据，不可以修改、但可以重复的存储场景
  • 字符串：一串文本字符串的存储场景
  • 集合： 有一批数据，需要去重存储场景
  • 字典： 有一批数据，需要用key检索value的存储场景

二、数据容器-列表[list]

解释：存放数据，但可以修改

语法：[元素1,元素2,...]

1. 列表的创建

# 案例
name_list = ['1','sadas',True,'4','5']       # 多种类型，也可以嵌套多个列表
print(name_list)
print(type(name_list))          # 输出都是列表类型： <class 'list'>

2. 列表的方法

2.1. 查询元素

语法：列表.index(元素)

# 案例
my_list = ["python","wl","1"]
index = my_list.index("python")
print(f"index的下表索引值是: {index}")        # 输出：0

2.2. 索引获取元素

# 案例
name_list = ['1','sadas',True,'4','5']      # 代表0,1,2,3,4,5 或者 -5.-4,-3,-2,-1
print(name_list[0])             			# 输出：1
print(name_list[-5])            			# 输出：1

# 案例
name_list = [['1','sadas'],[True,'4','5']]   # 嵌套多个列表
print(name_list[0][0])          			# 输出：1
print(name_list[1][0])          			# 输出：True

2.3. 修改索引元素

语法：列表[下标] = 值

# 案例
my_list = ["python","wl","1"]
my_list[2] = 2                              # 正向下标
print(f"修改后my_list值: {my_list}")			# 输出：['python', 'wl', 2]my_list[-1] = -1                            # 正向下标
print(f"修改后my_list值: {my_list}")			# 输出：['python', 'wl', -1]

2.4. 插入列表元素

语法：列表.insert(下标,元素) ，指定索引位置插入

# 案例
my_list = ["python","wl","1"]
my_list.insert(0,"888")
print(f"插入一个数888后：{my_list}")			# 输出：['888', 'python', 'wl', '1']

2.5. 追加元素

语法：列表.append(元素), 追加到尾部

# 案例
my_list = ["python","wl","1"]
my_list.append("999")                     	# 也可以追加新列表 my_list.append([555,222])
print(f"最后追加元素999：{my_list}")			# 输出：['python', 'wl', '1', '999']

2.6. 删除元素

语法1： del 列表[下标] del 仅仅完成删除

# 案例
my_list = ["python","wl","1"]                  	# 语法1
del my_list[0]                                 	# 注意括号，del 仅仅完成删除
print(f"删除第一个python: {my_list}")			# 输出：['wl', '1']

语法2： 列表.pop(下标) 不仅删除元素，还可以返回值得到它

#案例
my_list = ["python","wl","1"]                  	# 语法2
my_pop = my_list.pop(0)                        	# 注意括号，pop不仅删除，还可以返回值得到它
print(f"删除第一个python: {my_list},删除的是 {my_pop}")		# 输出：['wl', '1'],删除的是 python

语法3： 列表.remove(元素) 删除某一个元素，从前往后第一个删除

# 案例
my_list = ["python","python","wl","1"]         	# 语法3
my_list.remove('python')						# 只删除第一个
print(f"删除第一个python: {my_list}")           	# 输出：['python', 'wl', '1']

2.7. 清空元素

语法： 列表.clear()

# 案例
my_list = ["python","wl","1"]
my_list.clear()
print(f"全部清空列表,结果是：{my_list}")            # 输出：[]

2.8. 统计某个元素

语法： 列表.count()

# 案例
my_list = [1,2,2,1,3,4]
count = my_list.count(1)
print(f"列表1的数量是：{count}")                   # 输出：2

2.9. 统计所有元素

语法：len(列表)

# 案例
my_list = ["python","wl","1"]
print(len(my_list))                             # 输出：3

3. 列表的遍历

3.1. 利用while循环获取元素

解释：1.自定循环条件，自行控制 2.通过条件控制做到无限循环

# 案例  依次取出列表元素
my_list = ["python","wl","1"]
print(type(my_list))
index = 0
while index < len(my_list):     # len 表示列表中总数小于0，进行循环a = my_list[index]print(f"列表的 {index}元素：{a}")index += 1                  # index = index + 1

3.2. 利用for循环获取元素

解释：1.不可以自定循环条件，只能从容器里取出数据 2.理论不可以无限循环

# 案例  依次取出列表元素
my_list = ["python",3,4,5]
for a in my_list:print(f"列表的元素：{a}")

3.3. 利用pandas制作表格，并存储

# 案例
import pandas as pdlist = [{'mtime': '2022-12-05', 'title': '国家卫健委', 'digest': '全国累计报告接种新冠病毒疫苗344429.5万剂次'}, {'mtime': '2022-12-05', 'title': '5日0—12时重庆', 'digest': '新增本土确诊病例73例和本土无症状感染者919例'}]
data = pd.DataFrame(list)
print(data)
# 输出：
#         mtime       title                     digest
# 0  2022-12-05       国家卫健委  全国累计报告接种新冠病毒疫苗344429.5万剂次
# 1  2022-12-05  5日0—12时 重庆   新增本土确诊病例73例和本土无症状感染者919例# 存入数据,utf-8-sig编码防止中文乱码
data.to_csv("sj1.csv",encoding="utf-8-sig")

3.4. 使用for循环依次打印数据

# 案例
list = [{'mtime': '2022-12-05', 'title': '国家卫健委', 'digest': '全国累计报告接种新冠病毒疫苗344429.5万剂次'}, {'mtime': '2022-12-05', 'title': '5日0—12时重庆', 'digest': '新增本土确诊病例73例和本土无症状感染者919例'}]
for item in list:mtime = item["mtime"]title = item["title"]digest = item["digest"]print(f"{mtime}, {title}, {digest}")
# 输出：
# 2022-12-05, 国家卫健委, 全国累计报告接种新冠病毒疫苗344429.5万剂次
# 2022-12-05, 5日0—12时重庆, 新增本土确诊病例73例和本土无症状感染者919例

3.5. 使用while循环依次打印数据

# 案例
list = [{'mtime': '2022-12-05', 'title': '国家卫健委', 'digest': '全国累计报告接种新冠病毒疫苗344429.5万剂次'}, {'mtime': '2022-12-05', 'title': '5日0—12时重庆', 'digest': '新增本土确诊病例73例和本土无症状感染者919例'}]
x = 0
while x < len(list):mtime = list[x]["mtime"]title = list[x]["title"]digest = list[x]["digest"]print(f"{mtime}, {title}，{digest}")x += 1# 输出：
# 2022-12-05, 国家卫健委, 全国累计报告接种新冠病毒疫苗344429.5万剂次
# 2022-12-05, 5日0—12时重庆, 新增本土确诊病例73例和本土无症状感染者919例

三、数据容器-元祖(tuple)

解释：存放数据，不可修改(只读方式)，但可以修改元素内容；

语法：(元素1，元素2，...)

1. 元祖的创建

# 案例
my1_tuple = ("python","wl","1")
my2_tuple = ()                              	# 空元祖方式1
my3_tuple = tuple()                         	# 空元祖方式2
my4_tuple = ("python",)                     	# 注意：定义一个元祖，需要加,否则就成了字符串类型
my5_tuple = (["python","wl"],"1")          		# 注意：元祖里的列表可以删除，修改等
print(f"my1_tuple类型是: {type(my1_tuple)},内容是：{my1_tuple}")
print(f"my2_tuple类型是: {type(my2_tuple)},内容是：{my2_tuple}")
print(f"my3_tuple类型是: {type(my3_tuple)},内容是：{my3_tuple}")
print(f"my4_tuple类型是: {type(my4_tuple)},内容是：{my4_tuple}")
print(f"my5_tuple类型是: {type(my5_tuple)},内容是：{my5_tuple}")
my5_tuple[0][1] = "修改内容"
print(f"修改的内容后：{my5_tuple}")           	# 输出：(['python', '修改内容'], '1')
del my5_tuple[0][0]                        	 	# 删除元祖中的列表值
print(f"删除元祖中列表第一个值：{my5_tuple}")    	# 输出：(['wl'], '1')

2. 元祖的方法

2.1. 元祖-获取元素

# 案例 
my_tuple = ((1,2,3),(7,8,9))    		# 元祖支持嵌套
print(f"my_tuple取出9的数据: {my_tuple[1][2]}")		# 输出9

2.2. 元祖-查询元素

语法： 元祖.index

# 案例 
my_tuple = ('python','wl',1,'python')
print(my_tuple.index('python'))              # 输出：0

2.3. 元祖-统计某个元素

语法： 元祖.count

# 案例 
my_tuple = ('python','wl',1,'python')
print(my_tuple.count('python'))              # 输出：2

2.4. 统计-统计所有元素

语法： 元祖.count

# 案例 
my_tuple = ('python','wl',1,'python')
print(len(my_tuple))                         # 输出：4

3. 元祖的遍历

3.1. 利用while循环获取元素

解释：1.自定循环条件，自行控制 2.通过条件控制做到无限循环

# 案例  依次取出元祖元素
my_tuple = ("python","wl","1")
print(type(my_tuple))
index = 0
while index < len(my_tuple):     # len 表示列表中总数小于0，进行循环a = my_tuple[index]print(f"元祖的 {index}元素：{a}")index += 1                  # index = index + 1

3.2. 利用for循环获取元素

解释：1.不可以自定循环条件，只能从容器里取出数据 2.理论不可以无限循环

# 案例  依次取出元祖元素
my_tuple = ("python",3,4,5)
print(type(my_tuple))
for a in my_tuple:print(f"元祖的元素：{a}")

四、数据容器-字符串(str)

特点：不支持修改

1. 字符串的方法

1.1. 字符串-索引获取元素

注意：空格也算一个字符

# 案例
my_str = "i is wl"
v1 = my_str[0]
v2 = my_str[-1]
print(f"首个值v1：{v1},最后值v2：{v2}")  # 输出：v1：i, v2：c

1.2. 字符串-查找元素

语法：字符串.index(值)

# 案例
my_str = "i is wl"
v = my_str.index("is")
print(f"and的起始下标v：{v}")            # 输出：2

1.3. 字符串-替换元素

语法：字符串.replace(原值，现值)

# 案例
my_str = "i is wl"
v = my_str.replace("i","t")
print(f"把所有的i替换成t：{v}")          # 输出：t ts wl

1.4. 字符串-分割元素

语法：字符串.split(分割值)

# 案例
my_str = "i is wl"
v = my_str.split( )                       # 空格切分
print(f"用空格风格my_str：{v}")            # 输出：['i', 'is', 'wl']

1.5. 字符串-规整元素

语法：字符串.strip(去除值) ，空代表去除前后空格

# 案例
my_str = "12i is wl21"
v = my_str.strip("12")                     # 去除12,实际去除“1”和“2”
print(f"去掉12后my_str：{v}")              # 输出：i is wl

1.6. 字符串-统计某个元素

语法：字符串count(统计值)

#案例
my_str = "i is wl"
v = my_str.count("i")
print(f"i出现的次数：{v}")                    # 输出：2

1.7. 字符串-统计所有元素

语法：字符串len()

#案例
my_str = "i is wl"
v = len(my_str)
print(f"my_str总数长度是：{v}")                  # 输出：8

五、数据容器-集合{set}

特点：相比其他，不支持重复集合，自带去重，并且输出是无序的

语法 ： 变量 = {元素1，元素2....}

1. 集合的创建

#案例
my_set = {"python","wl",4,"wl"}
print(my_set)                         	# 输出：{'python', 4, 'wl'}，故是无序的，不支持下标

2. 集合的方法

2.1. 集合-增加元素

# 案例
my_set = {"python","wl",4,"wl"}
my_set.add("Python")                    # 如果增加相同数据等于没有写
print(f"增加一个数my_set结果是：{my_set}")	# 输出：{'wl', 'Python', 'python', 4}

2.2. 集合-移除元素

# 案例
my_set = {"python","wl",4,"wl"}
my_set.remove("python")                 	# 删除所有，再去重
print(f"移除一个数my_set结果是：{my_set}") 	# 输出：{'wl', 4}

2.3. 集合-随机取出元素

# 案例
my_set = {"python","wl",4,"wl"}
element = my_set.pop()                  	# 随机取，无法指定
print(f"{element}")							# 
print(f"随机取一个数my_set结果是：{my_set}")	#

2.4. 集合-清空元素

# 案例
my_set = {"python","wl",4,"wl"}
my_set.clear()
print(f"清空my_set结果是：{my_set}")       # 输出：set()

2.5. 集合-取(消除)两个集合的差

# 案例
set1 = {1,2,3}
set2 = {2,3,4}
f_set = set1.difference(set2)
print(f"除set1中有而set2没有的结果是：{f_set}")   # 输出：{1}
set1.difference_update(set2)       				# 消除差集，集合2不变化
print(set1)                                     # 输出：{1}
print(set2)                                     # 输出：{2, 3, 4}

2.6. 集合-合并元素

# 案例
set1 = {1,2,3}
set2 = {2,3,4}
set3 = set1.union(set2)
print(f"集合合并后set3：{set3}")                # 输出：（去重）：{1, 2, 3, 4}

2.7. 集合-统计元素数量（去重）

# 案例
set1 = {1,2,3,2,3,4}
num = len(set1)
print(f"集合合并后set3：{num}")                  # 输出（去重）：4

3. 集合的遍历

说明：因为不支持下标索引，所以while循环不支持,支持for循环

# 案例
set1 = {1,2,3,2,3,4}
for a in set1:print(f"集合元素有：{a}")

六、数据容器-字典{dict}

解释：字和其相关联的含义
注意：字典可以任意类型，不允许重复，会覆盖

语法： 变量 = {key:value,key:value.....}

1. 字典的创建

# 案例
my_dict = {"张三":99,"李四":98,"王五":90}
print(f"my_dict类型是：{type(my_dict)}，内容是：{my_dict}")	# 输出：<class 'dict'>

2. 字典的方法

2.1. 字典-key取值

# 案例
my_dict = {"张三":99,"李四":98,"王五":90}
s = my_dict['张三']
print(f"张三对应的值是：{s}")               # 输出:99

2.2. 字典-嵌套取值

# 案例
my_dict = {"张三":{"语文":99,"数学":70},"李四":{"语文":88,"数学":80},"王五":{"语文":80,"数学":68}
}
s = my_dict["王五"]["数学"]
print(f"王五对应的数学值是：{s}")           # 输出：68

2.3. 字典-新增元素

# 案例
my_dict = {"张三":99,"李四":98,"王五":90}
my_dict['赵六'] = 77
print(f"新增赵六成绩后：{my_dict}")

2.4. 字典-更新元素

# 案例
my_dict = {"张三":99,"李四":98,"王五":90}
my_dict['张三'] = 77
print(f"新增赵六成绩后：{my_dict}")

2.5. 字典-删除元素

# 案例
my_dict = {"张三":99,"李四":98,"王五":90}
my_dict.pop("张三")
print(f"删除张三后：{my_dict}")

2.6. 字典-清空元素

# 案例
my_dict = {"张三":99,"李四":98,"王五":90}
my_dict.clear()
print(f"清空后：{my_dict}")

2.7. 字典-取key、value值

# 案例
my_dict = {"张三":99,"李四":98,"王五":90}
s = my_dict.keys()
print(f"{s}")
for s in my_dict:                       # for循环输出value值,不支持while循环print(f"{my_dict[s]}")

2.8. 字典-统计所有元素

# 案例
my_dict = {"张三":99,"李四":98,"王五":90}
num = len(my_dict)
print(f"数量是：{num}")                  # 输出：3

3. 字典的综合案例

要求：对名次为3的语文增加10分，并晋升一名次

# 案例
my_dict = {"张三":{"名次":8,"语文":99,"数学":70},"李四":{"名次":10,"语文":88,"数学":80},"王五":{"名次":3,"语文":80,"数学":68}
}
print(f"升级之前是：{my_dict}")for name in my_dict:if my_dict[name]["名次"] == 3:        # 当名次为3时，my_dict[name]["名次"] = 2         # 晋升一名次，改为2,my_dict[name]["语文"] += 10       # 语文成绩+10分
print(f"升级之后是：{my_dict}")

七、数据容器的切片

解释：从一个序列中，取出子序列
语法：序列[起始下标:结束下标:步长] 步长1表示，一个个取；2表示间隔一个取

1. 列表list

# 案例
my_list = [0,1,2,3,4,5,6,7,8,9]
result_1 = my_list[1:3]                     # 步长默认是1，可以不写
print(f"从第二个到四个取，result_1结果是：{result_1}")

2. 元祖tuple

# 案例
my_tuple = (0,1,2,3,4,5,6,7,8,9)
result_2 = my_tuple[::2]                    # 空代表从头到尾,2代表步长
print(f"从头到尾，间隔1，result_2结果是：{result_2}")

3. 字符串

# 案例
my_str = "0123456789"
result_3 = my_str[::-2]
print(f"从尾到头，间隔1，result_3结果是：{result_3}")

# 案例 正常取出数 "我是你哥"
my_str = "哥大我叫请，啊哥你是我，好你"
s1 = my_str[::-1][3:7]                          # 先倒转，再取值。注意最后的下标索引
print(f"方式s1结果是：{s1}")
s2 = my_str[7:11][::-1]                         # 先取值，再倒转。注意最后的下标索引
print(f"方式s2结果是：{s2}")
s3 = my_str.split("，")[1].replace("啊","")[::-1]      # 先用，分割取值第二个再把“啊”替换掉 最后倒序
print(f"方式s3结果是：{s3}")

八、数据容器的通用操作（排序、转换）

# 案例
my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefgh"
my_set = {1,2,3,4,5}
my_dict = {"key1":1,"key2":2,"key3":3}

1. 容器取值（max）

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)}")

2. 容器转列表

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)}")

3. 容器转元祖

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)}")

4. 容器转字符串、集合

解释：字典dict不支持，缺少键值对；字符串、集合都是无序)

5. 容器的排序

5.1. 排序

语法：sorted(容器,reverse=False)

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)}")

5.2. 降序

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)}")

5.3. 根据数字下标定义排序方法 sort

my_list = [["a",67],["a",7],["a",52]]# 方式1
def sort_key(element):return element[1]
my_list.sort(key=sort_key,reverse=False)       # True/flase:表示升序降序# 方式2 利用匿名函数lambda
my_list.sort(key=lambda element:element[1],reverse=False)
print(my_list)

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

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

相关文章

Dubbo之PojoUtils源码分析

Dubbo之PojoUtils源码分析

功能概述 PojoUtils是一个工具类&#xff0c;能够进行深度遍历&#xff0c;将简单类型与复杂类型的对象进行转换&#xff0c;在泛化调用时用到&#xff08;在泛化调用中&#xff0c;主要将Pojo对象与Map对象进行相互转换&#xff09; 功能分析 核心类PojoUtils分析 主要成员…
阅读更多...
Jacoco XML 解析

Jacoco XML 解析

1 XML解析器对比 1. DOM解析器&#xff1a; ○ 优点&#xff1a;易于使用&#xff0c;提供完整的文档树&#xff0c;可以方便地修改和遍历XML文档。 ○ 缺点&#xff1a;对大型文档消耗内存较多&#xff0c;加载整个文档可能会变慢。 ○ 适用场景&#xff1a;适合小型XML文档…
阅读更多...
函数式编程-Stream流学习第二节-中间操作

函数式编程-Stream流学习第二节-中间操作

1 Stream流概述 java8使用的是函数式编程模式,如同它的名字一样&#xff0c;它可以用来对集合或者数组进行链状流式操作&#xff0c;让我们更方便的对集合或者数组进行操作。 2 案例准备工作 我们首先创建2个类一个作家类&#xff0c;一个图书类 package com.stream.model;…
阅读更多...
03.sqlite3学习——数据类型

03.sqlite3学习——数据类型

目录 sqlite3学习——数据类型 SQL语句的功能 SQL语法 SQL命令 SQL数据类型 数字类型 整型 浮点型 定点型decimal 浮点型 VS decimal 日期类型 字符串类型 CHAR和VARCHAR BLOB和TEXT SQLite 数据类型 SQLite 存储类 SQLite 亲和类型(Affinity)及类型名称 Boo…
阅读更多...
RT-Thread开发，使用SCons编译，生成静态库，并进行链接生成MCU程序

RT-Thread开发，使用SCons编译，生成静态库，并进行链接生成MCU程序

一、SCons 简介 SCons 是一个开放源代码、以 Python 语言编写的下一代的程序建造工具。它最初的名字是 ScCons, 基于由 perl 语言编写的 Cons 软件开发而成，它在 2000 年 8 月获得了由 Software Carpentry 举办的 SC 建造比赛的大奖。现在 ScCons 已经被改名为 SCons，目的是为…
阅读更多...
opencv案例03 -基于OpenCV实现二维码生成，发现，定位，识别

opencv案例03 -基于OpenCV实现二维码生成，发现，定位，识别

1.二维码的生成 废话不多说&#xff0c;直接上代码 # 生成二维码 import qrcode# 二维码包含的示例数据 data "B0018" # 生成的二维码图片名称 filename "qrcode.png" # 生成二维码 img qrcode.make(data) # 保存成图片输出 img.save(filename)img.sh…
阅读更多...
vue关闭弹窗刷新父页面 this.$refs

vue关闭弹窗刷新父页面 this.$refs

代码截图 主页面 弹出框页面 接这一篇文章后续 参考链接
阅读更多...
Python 数据分析——matplotlib 快速绘图

Python 数据分析——matplotlib 快速绘图

matplotlib采用面向对象的技术来实现&#xff0c;因此组成图表的各个元素都是对象&#xff0c;在编写较大的应用程序时通过面向对象的方式使用matplotlib将更加有效。但是使用这种面向对象的调用接口进行绘图比较烦琐&#xff0c;因此matplotlib还提供了快速绘图的pyplot模块。…
阅读更多...
Python迭代器和生成器

Python迭代器和生成器

一、迭代器 1.1、什么是迭代 迭代是指反复的执行一个过程&#xff0c;每次执行都会根据前一次的结果进行调整和优化。在计算机编程中&#xff0c;迭代常常用于循环执行某个操作&#xff0c;直到达到特定的条件或达成目标。迭代也可以用于指代软件开发中的“迭代开发”&#x…
阅读更多...
华为OD-素数之积

华为OD-素数之积

题目描述 RSA加密算法在网络安全世界中无处不在&#xff0c;它利用了极大整数因数分解的困难度&#xff0c;数据越大&#xff0c;安全系数越高&#xff0c;给定一个32位正整数&#xff0c;请对其进行因数分解&#xff0c;找出是哪两个素数的乘积。 输入描述 1. 一个正整数nu…
阅读更多...
gateway动态路由和普通路由+负载均衡，借助eureka

gateway动态路由和普通路由+负载均衡，借助eureka

gateway 中的动态路由和普通路由是相互独立配置的注意gateway访问的微服务如果是提供feign调用其他服务的 &#xff0c;要用普通路由方式&#xff0c;不能用动态路由 spring:cloud:gateway:enabled: truediscovery:locator:enabled: true #表示动态路由&#xff0c;必须指定服…
阅读更多...
R语言主成分分析

R语言主成分分析

R语言主成分分析 之前介绍过怎么用SPSS进行主成分分析(PCA)&#xff0c;已经忘了的朋友们可以到主页看看 今天主要介绍下R语言主成分分析的几种方法。都是入门级别&#xff0c;跟着我一步步走&#xff0c;一点都不难哈~ 首先调用R语言自带的数据集&#xff0c;USArrests。这…
阅读更多...
蓝桥杯上岸每日N题 (修剪灌木)

蓝桥杯上岸每日N题 (修剪灌木)

大家好 我是寸铁 希望这篇题解对你有用&#xff0c;麻烦动动手指点个赞或关注&#xff0c;感谢您的关注 不清楚蓝桥杯考什么的点点下方&#x1f447; 考点秘籍 想背纯享模版的伙伴们点点下方&#x1f447; 蓝桥杯省一你一定不能错过的模板大全(第一期) 蓝桥杯省一你一定不…
阅读更多...
CSS中的flex布局详细讲解

CSS中的flex布局详细讲解

Flex 布局 Flex 布局是一种现代的 CSS 布局模型&#xff0c;用于实现灵活的盒子布局。它提供了强大的布局能力&#xff0c;使得元素可以自动调整大小、对齐和分布&#xff0c;适用于构建响应式和可伸缩的布局。 Flex 布局使用 flex 容器和 flex 项目的概念。容器是一个父元素…
阅读更多...
【Go 基础篇】Go语言中的数组：初识与应用

【Go 基础篇】Go语言中的数组：初识与应用

Go语言以其简洁、高效和强大的特性在编程界广受欢迎。数组作为一种基本的数据结构&#xff0c;在各种应用场景中扮演着重要角色。本文将引入Go语言中的数组&#xff0c;介绍其特点、创建、初始化以及基本应用&#xff0c;为你打开数组的大门。 前言 数组是一种固定大小的数据…
阅读更多...
七层、四层和五层网络模型区别和联系

七层、四层和五层网络模型区别和联系

七层、四层和五层网络模型区别和联系 概述OSI网络7层模型&#xff08;概念型框架&#xff09;概述图片分析 四层模型概述常用协议OSI与TCP/IP四层的区别 五层模型概述三种网络模型对比 总结 概述 网络模型-七层模型&#xff08;OSI模型&#xff09;、五层协议体系结构和TCP/IP…
阅读更多...
性能优化之分库分表

性能优化之分库分表

1、什么是分库分表 1.1、分表 将同一个库中的一张表&#xff08;比如SPU表&#xff09;按某种方式&#xff08;垂直拆分、水平拆分&#xff09;拆分成SPU1、SPU2、SPU3、SPU4…等若干张表&#xff0c;如下图所示&#xff1a; 1.2、分库 在表数据不变的情况下&#xff0c;对…
阅读更多...
“R语言+遥感“水环境综合评价方法

“R语言+遥感“水环境综合评价方法

详情点击链接&#xff1a;"R语言遥感"水环境综合评价方法 一&#xff1a;R语言 1.1 R语言特点&#xff08;R语言&#xff09; 1.2 安装R&#xff08;R语言&#xff09; 1.3 安装RStudio&#xff08;R语言&#xff09; &#xff08;1&#xff09;下载地址 &…
阅读更多...
前端开发中的单伪标签清除和双伪标签清除

前端开发中的单伪标签清除和双伪标签清除

引言 在前端开发中&#xff0c;我们经常会遇到一些样式上的问题&#xff0c;其中之一就是伪元素造成的布局问题。为了解决这个问题&#xff0c;我们可以使用伪标签清除技术。本篇博客将介绍单伪标签清除和双伪标签清除的概念、用法和示例代码&#xff0c;并详细解释它们的原理…
阅读更多...
服务器卡顿如何排查？

服务器卡顿如何排查？

服务器网络卡&#xff0c;一般情况下&#xff0c;请先检查您服务器的使用情况。 1.CPU使用率是否大于50%。 2.网络使用率是否过高。 3.内存使用率是否过高。 如果出现上述情况&#xff0c;则表明您的服务器或网络无法承载您目前的服务&#xff0c;请联系技术人员调整您的资…
阅读更多...
最新文章

Copyright @ 2022~2023