探索Python数据容器之乐趣:列表与元组的奇妙旅程!

文章目录

  • 零 数据容器入门
  • 一 数据容器:list(列表)
    • 1.1 列表的定义
    • 1.2 列表的下表索引
    • 1.3 列表的常用操作
      • 1.3.1 列表的查询功能
      • 1.3.2 列表的修改功能
      • 1.3.3 列表常用方法总结
    • 1.4 补充:append与extend对比
    • 1.5 list(列表)的遍历
    • 1.6 补充:while循环和for循环对比
  • 二 数据容器:tuple(元组)
    • 2.1 元组的定义
    • 2.2 疑惑解答
    • 2.3 元组的操作
    • 2.4 注意事项
    • 2.5 练习案例:元组的基本操作

零 数据容器入门

  • Python中的数据容器:

    • 一种可以容纳多份数据的数据类型,容纳的每一份数据称之为1个元素
    • 每一个元素,可以是任意类型的数据,如字符串、数字、布尔等。
  • 数据容器根据特点的不同,如:是否支持重复元素、是否可以修改、是否有序,等分为5类,分别是:
    列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

一 数据容器:list(列表)

1.1 列表的定义

  • 在Python中,list(列表)是一种常用的数据容器,用于存储多个元素。列表是可变(mutable)的,可以在创建后随时修改它,添加或删除元素。
  • 列表可以包含不同类型的元素,例如整数、字符串、浮点数等,甚至可以包含其他列表。
  • 创建列表的语法为用方括号 [] 括起来的一系列元素,每个元素之间用逗号 , 分隔。例如:
my_list = [1, 2, 3, "hello", 3.14]
# 列表[下标索引], 从前向后从0开始,每次+1,  从后向前从-1开始,每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范;通过下标索引取数据,一定不要超出范围
# print(my_list[3])
  • 列表索引从0开始,所以第一个元素可以通过 my_list[0] 来访问,第二个元素通过 my_list[1],依此类推。

列表可以一次存储多个数据,且可以为不同的数据类型,支持嵌套

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

1.2 列表的下表索引

  • 列表中的每一个元素,都有其位置下标索引,从前向后的方向,从0开始,依次递增
    在这里插入图片描述
  • 可以反向索引,也就是从后向前:从-1开始,依次递减(-1、-2、-3…)
    在这里插入图片描述
  • 如果列表是嵌套的列表,同样支持下标索引

在这里插入图片描述

  • 演示
# 列表[下标索引], 从前向后从0开始,每次+1,  从后向前从-1开始,每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范;通过下标索引取数据,一定不要超出范围
# print(my_list[3])# 通过下标索引取出数据(倒序取出)
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

1.3 列表的常用操作

1.3.1 列表的查询功能

  • 使用 index() 方法来查找列表中某个元素第一次出现的索引(下标)。

  • index() 方法接受一个参数,即要查找的元素的值,并返回该元素在列表中的索引值。如果该元素不存在于列表中,该方法将引发一个 ValueError 异常。

  • index() 方法查找元素的示例:

    my_list = [10, 20, 30, 40, 50]# 查找元素的索引
    index_30 = my_list.index(30)
    print(index_30)  # 输出: 2index_40 = my_list.index(40)
    print(index_40)  # 输出: 3# 查找不存在的元素会引发异常
    try:index_60 = my_list.index(60)
    except ValueError as e:print("元素不存在:", e)  # 输出: 元素不存在: 60 is not in list
    
  • 请注意,index() 方法只会返回找到的第一个匹配项的索引。


  • 如果有多个相同的元素,可能需要使用循环来找到所有匹配项的索引。
my_list = [10, 20, 30, 40, 30, 50]# 找到所有匹配项的索引
target = 30
indices = []
for i in range(len(my_list)):if my_list[i] == target:indices.append(i)print(indices)  # 输出: [2, 4]

1.3.2 列表的修改功能

  1. 修改元素:通过索引来修改列表中的元素。
    my_list = [1, 2, 3, "hello", 3.14]
    my_list[2] = 42
    print(my_list)  # 输出: [1, 2, 42, 'hello', 3.14]
    my_list[-1]=-1
    print(my_list) # 输出: [1, 2, 42, 'hello', -1]
    
  2. 插入元素:使用insert()方法在指定位置插入指定元素
    • 第一个参数是要插入的索引,第二个参数是要插入的元素。
my_list = [1, 2, 3, 5]
my_list.insert(3, 4)
print(my_list)  # 输出: [1, 2, 3, 4, 5]
  1. 添加元素

    • 使用 append() 方法在列表末尾添加元素。
    • append() 方法没有返回值(即返回值为None),它会直接在原列表上进行修改。
    my_list = [1, 2, 3, "hello", 3.14]
    my_list.append("world")
    print(my_list)  # 输出: [1, 2, 42, 'hello', 3.14, 'world']
    
    • 使用extend()方法,将其它数据容器的内容取出,依次追加到列表尾部
    • 列表的 extend() 方法用于将一个可迭代对象的元素添加到列表的末尾。可迭代对象可以是另一个列表、元组、字符串,或者任何支持迭代的数据类型。extend() 方法会逐个迭代可迭代对象,并将其中的元素依次添加到列表中。
    # 列表扩展
    list1 = [1, 2, 3]
    list2 = [4, 5, 6]
    list1.extend(list2)
    print(list1)  # 输出: [1, 2, 3, 4, 5, 6]# 字符串扩展
    my_list = [1, 2, 3]
    my_string = "hello"
    my_list.extend(my_string)
    print(my_list)  # 输出: [1, 2, 3, 'h', 'e', 'l', 'l', 'o']# 可迭代对象扩展
    my_list = [1, 2, 3]
    my_tuple = (4, 5, 6)
    my_list.extend(my_tuple)
    print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]
  2. 删除元素:

    1. remove() 方法:通过值删除元素。该方法将从列表中删除第一个匹配到的值。如果要删除所有匹配的值,可以使用循环结合 remove() 方法来实现。
    my_list = [1, 2, 3, 2, 4]
    my_list.remove(2)
    print(my_list)  # 输出: [1, 3, 2, 4]
    
    my_list = [1, 2, 3, 2, 4]# 删除所有匹配的值
    value_to_remove = 2
    while value_to_remove in my_list:my_list.remove(value_to_remove)print(my_list)  # 输出: [1, 3, 4]
    
    1. pop() 方法:通过索引删除元素,并返回被删除的元素。如果不提供索引,它将删除并返回列表的最后一个元素。
    my_list = [1, 2, 3, 4]
    deleted_element = my_list.pop(1)
    print(deleted_element)  # 输出: 2
    print(my_list)  # 输出: [1, 3, 4]deleted_element = my_list.pop()
    print(deleted_element)  # 输出: 4
    print(my_list)  # 输出: [1, 3]
    
    1. del 语句:通过索引使用 del 语句删除元素。与 pop() 方法不同,del 语句不返回被删除的元素。
    my_list = [1, 2, 3, 4]
    del my_list[1]
    print(my_list)  # 输出: [1, 3, 4]
    
    1. 使用切片删除多个元素:通过切片语法删除多个元素。
      • my_list[:2]:这是一个切片操作,表示获取从索引 0 到索引 2(不包括索引 2)的子列表。这将返回 [1, 2],这是原列表 my_list 中索引为 01 的元素组成的子列表。

      • my_list[3:]:这也是一个切片操作,表示获取从索引 3 到列表末尾的子列表。这将返回 [4, 5],这是原列表 my_list 中索引为 34 的元素组成的子列表。

    my_list = [1, 2, 3, 4, 5]
    my_list = my_list[:2] + my_list[3:]
    print(my_list)  # 输出: [1, 2, 4, 5]
    
    1. 清空列表:使用 clear() 方法可以清空列表中的所有元素。
    my_list = [1, 2, 3, 4, 5]
    my_list.clear()
    print(my_list)  # 输出: []
    
    1. 统计某元素在列表内的数量:.count(元素)方法统计元素在列表中的个数
    mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
    count = len(mylist)
    print(f"列表的元素数量总共有:{count}个")
    
    1. 统计元素个数:len() 方法用于获取列表(或其他可迭代对象)的长度,即列表中包含的元素个数
      • len() 方法是一个内置函数,它不仅可以用于列表,还可以用于字符串、元组、集合等可迭代对象。
    my_list = [1, 2, 3, 4, 5]
    length = len(my_list)
    print(length)  # 输出: 5
    

1.3.3 列表常用方法总结

方法描述示例
append()在列表末尾添加一个元素my_list.append(10)
extend()将一个可迭代对象中的元素逐个添加到列表末尾my_list.extend([20, 30, 40])
insert()在指定位置插入一个元素my_list.insert(1, 15)
remove()删除第一个匹配的元素my_list.remove(30)
pop()删除并返回指定索引的元素(默认为最后一个元素)my_list.pop(1)
del 语句通过索引删除元素del my_list[0]
clear()删除列表中的所有元素my_list.clear()
index()返回指定元素的索引(第一个匹配项)index = my_list.index(40)
count()统计指定元素在列表中出现的次数count = my_list.count(20)
sort()对列表进行排序(原地排序,不返回新列表)my_list.sort()
reverse()反转列表中的元素顺序my_list.reverse()
切片操作从列表中获取子列表或修改多个元素sub_list = my_list[1:4], my_list[1:4] = [8, 9, 10]

1.4 补充:append与extend对比

  • append()extend() 方法是两个常用的方法,但它们有着不同的用途和行为。
  1. append() 方法:
  • 用途:append() 方法用于将指定的元素作为一个整体添加到列表的末尾。
  • 参数:append() 方法接受一个参数,即要添加到列表末尾的元素。
  • 返回值:append() 方法没有返回值,其返回值为 None
  • 修改原列表:append() 方法直接在原列表上进行修改,将指定的元素添加到列表的末尾。
  • 示例:
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]my_list.append([5, 6])
print(my_list)  # 输出: [1, 2, 3, 4, [5, 6]]
  1. extend() 方法:
  • 用途:extend() 方法用于将一个可迭代对象的元素逐个添加到列表的末尾。
  • 参数:extend() 方法接受一个可迭代对象作为参数,例如列表、元组、字符串等。
  • 返回值:extend() 方法没有返回值,其返回值为 None
  • 修改原列表:extend() 方法直接在原列表上进行修改,将可迭代对象中的元素逐个添加到列表的末尾。
  • 示例:
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]

总结:

  • 使用 append() 方法,您可以将一个元素作为整体添加到列表的末尾。

  • 使用 extend() 方法,您可以将一个可迭代对象中的元素逐个添加到列表的末尾。

  • 两种方法都直接在原列表上进行修改,而且它们没有返回值,其返回值为 None

  • 选择使用 append() 还是 extend() 取决于您要添加的元素类型和添加的方式。如果您要将一个单一元素作为整体添加到列表,使用 append()。如果您有一个可迭代对象,希望将其中的所有元素逐个添加到列表,使用 extend()

1.5 list(列表)的遍历

  • 在Python中,列表是一种可迭代对象,可以通过遍历来访问其中的元素。有几种方式可以对Python列表进行遍历:
  1. 使用for循环:
    my_list = [1, 2, 3, 4, 5]for item in my_list:print(item)
    

  1. 使用索引和range函数:
    my_list = [1, 2, 3, 4, 5]for i in range(len(my_list)):print(my_list[i])
    

  1. 使用enumerate函数(同时获取索引和元素):
    my_list = [1, 2, 3, 4, 5]for index, item in enumerate(my_list):print(f"Index: {index}, Item: {item}")
    

  1. 使用while循环和索引:
    my_list = [1, 2, 3, 4, 5]
    index = 0while index < len(my_list):print(my_list[index])index += 1
    

1.6 补充:while循环和for循环对比

while循环和for循环,都是循环语句,但细节不同:

在循环控制上:

  • while循环可以自定循环条件,并自行控制
  • for循环不可以自定循环条件,只可以一个个从容器内取出数据

在无限循环上:

  • while循环可以通过条件控制做到无限循环
  • for循环理论上不可以,因为被遍历的容器容量不是无限的

在使用场景上:

  • while循环适用于任何想要循环的场景
  • for循环适用于,遍历数据容器的场景或简单的固定次数循环场景

二 数据容器:tuple(元组)

2.1 元组的定义

  • 元组同列表一样,都是可以封装多个、不同类型的元素在内。但最大的不同点在于:元组一旦定义完成,就不可修改
  • 元组定义:定义元组使用小括号,且使用逗号隔开各个数据,数据可以是不同的数据类型。
# 定义元组字面量
(元素,元素,元素,...)
# 定义元组变量
变量名称=(元素,元素,元素,...)
# 定义空元组
变量名称=()
变量名称=tuple()
# 定义一个空元组
empty_tuple = ()# 定义一个包含多个元素的元组
my_tuple = (1, 2, "Hello", 3.14, [4, 5])# 元组中也可以包含其他元组
nested_tuple = (1, (2, 3), ("a", "b", "c"))# 单个元素的元组需要在元素后面加上逗号,以区分其与括号运算符的使用
single_element_tuple = (42,)

2.2 疑惑解答

  • 元组只有一个数据,这个数据后面要添加逗号。

  • 在Python中,如果要定义只有一个元素的元组,需要在元素后面添加逗号,否则Python会将其视为其他数据类型而不是元组。

  • 这是因为在使用圆括号时,Python解释器需要通过逗号来区分表达式和元组。当只有一个元素且没有逗号时,解释器无法确定它是一个元组还是一个普通的表达式。

    • 以下是正确定义只包含一个元素的元组的示例:
    # 只包含一个元素的元组,需要在元素后面添加逗号
    single_element_tuple = (42,)
    print(type(single_element_tuple))  # 输出:<class 'tuple'>
    
    • 如果没有添加逗号:
    # 没有添加逗号,解释器将不会将其识别为元组
    not_a_tuple = (42)
    print(type(not_a_tuple))  # 输出:<class 'int'>
    
    • 所以,为了确保只包含一个元素的表达式被正确解释为元组,必须添加逗号。

2.3 元组的操作

  • 元组由于不可修改的特性,所以其操作方法非常少
  • Python元组的常见操作:
操作示例描述
访问元素my_tuple[0]使用索引访问元组中的元素。
切片my_tuple[1:4]使用切片获取元组中的子集。
连接tuple1 + tuple2使用加号(+)将两个元组连接起来。
复制my_tuple * 3使用乘号(*)复制元组。
元素检查element in my_tuple使用in关键字检查元素是否在元组中。
元素个数len(my_tuple)使用len()函数获取元组中元素的个数。
元素最值min(my_tuple)
max(my_tuple)
使用min()max()函数获取元组中的最小和最大值。
元组解包a, b, c = my_tuple将元组的元素解包到多个变量中。
查找元素索引my_tuple.index(element)返回元素在元组中第一次出现的索引。
统计元素出现次数my_tuple.count(element)返回元素在元组中出现的次数。

感谢您的提醒,这些方法是在处理元组时非常有用的功能,使得我们可以更方便地对元组进行操作和查询。


  1. 访问元素:可以使用索引来访问元组中的元素。
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])  # 输出:1
  1. 切片:可以使用切片来获取元组中的子集。
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1:4])  # 输出:(2, 3, 4)
  1. 连接:可以使用加号(+)将两个元组连接起来。
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
concatenated_tuple = tuple1 + tuple2
print(concatenated_tuple)  # 输出:(1, 2, 3, 4, 5, 6)
  1. 复制:可以使用乘号(*)复制元组。
my_tuple = (1, 2, 3)
duplicated_tuple = my_tuple * 3
print(duplicated_tuple)  # 输出:(1, 2, 3, 1, 2, 3, 1, 2, 3)
  1. 元素检查:可以使用 in 关键字检查元素是否在元组中。
my_tuple = (1, 2, 3)
print(2 in my_tuple)  # 输出:True
print(4 in my_tuple)  # 输出:False
  1. 元素个数:使用 len() 函数可以获取元组中元素的个数。
my_tuple = (1, 2, 3)
print(len(my_tuple))  # 输出:3
  1. 元素最值:可以使用 min()max() 函数获取元组中的最小和最大值。
my_tuple = (5, 2, 8, 1, 3)
print(min(my_tuple))  # 输出:1
print(max(my_tuple))  # 输出:8
  1. 元组解包:可以将元组的元素解包到多个变量中。
my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a)  # 输出:1
print(b)  # 输出:2
print(c)  # 输出:3
  1. 查找元素索引:index() 方法用于查找元组中指定元素的索引(第一次出现的位置)。如果元素不存在于元组中,会引发 ValueError 错误。
my_tuple = (10, 20, 30, 40, 20, 50)index_20 = my_tuple.index(20)
print("Index of 20:", index_20)  # 输出:Index of 20: 1index_60 = my_tuple.index(60)  # 元素 60 不在元组中,会引发 ValueError 错误
  1. 统计元素出现次数:count() 方法用于统计元组中指定元素的出现次数
my_tuple = (10, 20, 30, 40, 20, 50)count_20 = my_tuple.count(20)
print("Count of 20:", count_20)  # 输出:Count of 20: 2count_60 = my_tuple.count(60)
print("Count of 60:", count_60)  # 输出:Count of 60: 0

2.4 注意事项

  • 如果元组中包含可变对象,例如列表,那么列表内的内容是可以修改的。虽然元组本身不能变,但是列表是可变的,因此可以对列表内的元素进行修改。
  • 可以修改元组内的list的内容(修改元素、增加、删除、反转等)
    # 创建一个包含列表的元组
    my_tuple = ([1, 2, 3], [4, 5, 6])# 修改元组中列表的元素
    my_tuple[0][1] = 100
    my_tuple[1].append(7)
    my_tuple[1].remove(4)print(my_tuple)  # 输出:([1, 100, 3], [5, 6, 7])
    
  • 元组中list不可以替换list为其它list或其它类型
    # 创建一个包含列表的元组
    my_tuple = ([1, 2, 3], [4, 5, 6])# 尝试替换元组中的列表为其他列表
    new_list = [7, 8, 9]
    my_tuple[0] = new_list  # 会引发 TypeError 错误,元组不可赋值修改# 尝试直接替换列表为其他类型
    my_tuple[1] = "Hello"  # 会引发 TypeError 错误,元组不可赋值修改# 尝试修改元组内列表的元素
    my_tuple[0][1] = 100  # 这是可以的,因为元组中的列表是可变对象print(my_tuple)
    

2.5 练习案例:元组的基本操作

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

  • 请通过元组的功能(方法),对其进行

    1. 查询其年龄所在的下标位置
    2. 查询学生的姓名
    3. 删除学生爱好中的football
    4. 增加爱好:coding到爱好list内
  • 示例代码:

    student_info = ('周杰轮', 11, ['football', 'music'])# 1. 查询年龄所在的下标位置
    age_index = student_info.index(11)
    print("年龄所在的下标位置:", age_index)# 2. 查询学生的姓名
    name = student_info[0]
    print("学生的姓名:", name)# 3. 删除学生爱好中的football
    hobbies = student_info[2]
    if 'football' in hobbies:hobbies.remove('football')
    print("删除后的爱好列表:", hobbies)# 4. 增加爱好:coding到爱好list内
    hobbies.append('coding')
    print("增加爱好后的列表:", hobbies)# 最终的学生信息元组
    updated_student_info = (name, 11, hobbies)
    print("最终的学生信息元组:", updated_student_info)
  • 运行结果:

    年龄所在的下标位置: 1
    学生的姓名: 周杰轮
    删除后的爱好列表: ['music']
    增加爱好后的列表: ['music', 'coding']
    最终的学生信息元组: ('周杰轮', 11, ['music', 'coding'])
    

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

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

相关文章

C#实现SqlServer数据库同步

实现效果&#xff1a; 设计思路&#xff1a; 1. 开启数据库及表的cdc&#xff0c;定时查询cdc表数据&#xff0c;封装sql语句(通过执行类型&#xff0c;主键;修改类型的cdc数据只取最后更新的记录)&#xff0c;添加到离线数据表&#xff1b; 2. 线程定时查询离线数据表&#xf…

httpd+Tomcat(jk)的Web动静分离搭建

动静分离是指将动态请求和静态请求分别交给不同的服务器来处理&#xff0c;可以提高服务器的效率和性能。在Java Web开发中&#xff0c;常见的动态请求处理方式是通过Tomcat来处理&#xff0c;而静态请求则可以通过Apache服务器来处理。本文将详细讲解如何结合Apache和Tomcat来…

c++之STL详解

c之STL详解 泛型编程什么是STLSTL发展STL组件容器类型成员适配器STL迭代器STL算法顺序容器向量vector双端队列双端队列实现列表listc关联容器cmapmultimapsetmultiset迭代器函数对象集成函数对象自定义函数对象标准c库中算法STL算法头文件标准函数泛型算法例子自定函数作为算法…

SNAT与DNAT原理

SNAT和DNAT &#xff08;源地址转换和目标地址转换&#xff09; SNAT&#xff1a;源地址转换。内网到外网转换的是源地址。 DNAT&#xff1a;目标地址转换&#xff1a;外网到内网转换的是目的地址 &#xff08;把内部服务器的ip地址转换成一个所有人都可以访问的地址&#xff0…

【Spring】创建一个Spring项目与Bean对象的存储

目录 一、创建Spring项目 1、创建Maven项目 2、配置maven国内源 3、引入spring依赖 4、添加启动类 二、将Bean对象存储到Spring&#xff08;IoC容器&#xff09; 1、创建Bean对象 2、将Bean存储到spring&#xff08;容器&#xff09;中 3、获取Bean对象 3.1、Applicatio…

详解PHP反射API

PHP中的反射API就像Java中的java.lang.reflect包一样。它由一系列可以分析属性、方法和类的内置类组成。它在某些方面和对象函数相似&#xff0c;比如get_class_vars()&#xff0c;但是更加灵活&#xff0c;而且可以提供更多信息。反射API也可与PHP最新的面向对象特性一起工作&…

信息安全技术工业控制系统安全控制应用指南学习笔记

工业控制系统安全控制基线 根据工业控制系统在国家安全、经济建设、社会生活中的重要程度&#xff0c;遭到破坏后对国家安全、社会秩序、公共利益以及公民、法人和其他组织的合法权益的危害程度等&#xff0c;结合信息安全等级保护标准划分及实施效果分析&#xff0c;结合工业…

ElasticSearch详细操作

ElasticSearch搜索引擎详细操作以及概念 文章目录 ElasticSearch搜索引擎详细操作以及概念 1、_cat节点操作1.1、GET/_cat/nodes&#xff1a;查看所有节点1.2、GET/_cat/health&#xff1a;查看es健康状况1.3_、_GET/_cat/master&#xff1a;查看主节点1.4、GET/_cat/indices&a…

Linux初识网络基础

目录 网络发展 认识“协议 ” 网络协议 OSI七层模型&#xff1a; TCP/IP五层&#xff08;或四层&#xff09;模型 网络传输基本流程 网络传输流程图&#xff1a; 数据包封装和封用 网络中的地址 认识IP地址&#xff1a; 认识MAC地址&#xff1a; 网络发展 1.独立…

2023华数杯数学建模C题思路 - 母亲身心健康对婴儿成长的影响

# 1 赛题 C 题 母亲身心健康对婴儿成长的影响 母亲是婴儿生命中最重要的人之一&#xff0c;她不仅为婴儿提供营养物质和身体保护&#xff0c; 还为婴儿提供情感支持和安全感。母亲心理健康状态的不良状况&#xff0c;如抑郁、焦虑、 压力等&#xff0c;可能会对婴儿的认知、情…

解决树莓派“由于没有公钥,无法验证下列签名“

目录 简介&#xff1a;在换完国内源后&#xff0c;树莓派尝试更新同步/etc/apt/sources.list和/etc/apt/sources.list.d中列出的软件源的软件包版本也就是&#xff08;apt-get update&#xff09;和更新已安装的所有或者指定软件包&#xff08;也即是apt-get upgrade&#xff0…

输入框长度在XSS测试中如何绕过字符长度限制

大家好&#xff0c;这是我编写的第一篇文章&#xff0c;之所以会分享这个故事&#xff0c;是因为我花了几个晚上的时间&#xff0c;终于找到了解决某个问题的方法。故事如下&#xff1a; 几个月前&#xff0c;我被邀请参加一个非公共的漏洞悬赏项目&#xff0c;在初期发现了一些…

科技云报道:财税数字化时代,财务人实现RPA自由了吗?

企业数字化转型&#xff0c;财务是一个重要的切入点。随着数字化业务不断展开&#xff0c;新的系统、流程和数据源被不断引入&#xff0c;财务部门面临的是不断暴增的对账、处理报表、审计等日常工作。 如此大的工作量&#xff0c;即使是经验丰富的资深财务&#xff0c;也难免…

一篇文章,教你彻底掌握接口测试!

什么是接口测试 所谓接口&#xff0c;是指同一个系统中模块与模块间的数据传递接口、前后端交互、跨系统跨平台跨数据库的对接。而接口测试&#xff0c;则是通过接口的不同情况下的输入&#xff0c;去对比输出&#xff0c;看看是否满足接口规范所规定的功能、安全以及性能方面…

解决问题:ModuleNotFoundError: No module named ‘mmcv._ext‘,及安装mmcv-full的详细教程

解决问题**ModuleNotFoundError: No module named ‘mmcv._ext’**之前得先搞懂mmcv和mmcv-full的关系。 mmcv 和 mmcv-full 都是针对 PyTorch 的计算机视觉基础库,两者的主要区别是: mmcv 包含了 mmcv 的核心组件,例如运行器、回调函数、可视化工具等,打包体积较小。mmcv-fu…

C#,OpenCV开发指南(01)

C#&#xff0c;OpenCV开发指南&#xff08;01&#xff09; 一、OpenCV的安装1、需要安装两个拓展包&#xff1a;OpenCvSharp4和OpenCvSharp4.runtime.win 二、C#使用OpenCV的一些代码1、需要加头文件2、读取图片3、在图片上画矩形框4、 在图片上画直线 一、OpenCV的安装 1、需…

浅谈新电改背景下电网企业综合能源服务商业模式研究及发展方向

安科瑞 华楠 摘要: 新电改方案实施后&#xff0c;由于输配电价的改革和售电侧的放开&#xff0c;电网企业的盈利模式也随之发生了变化。这就要求电网企业转变服务理念与经营方式&#xff0c;来寻求竞争优势。基于“魏朱六要素商业模式”模型&#xff0c;对电网企业综合能源服务…

在Linux中安装MySQL

在Linux中安装MySQL 检测当前系统中是否安装MySQL数据库 命令作用rpm -qa查询当前系统中安装的所有软件rpm -qa|grep mysql查询当前系统中安装的名称带mysql的软件rpm -qa | grep mariadb查询当前系统中安装的名称带mariadb的软件 RPM ( Red-Hat Package Manager )RPM软件包管理…

【雕爷学编程】 MicroPython动手做(35)——体验小游戏3

知识点&#xff1a;什么是掌控板&#xff1f; 掌控板是一块普及STEAM创客教育、人工智能教育、机器人编程教育的开源智能硬件。它集成ESP-32高性能双核芯片&#xff0c;支持WiFi和蓝牙双模通信&#xff0c;可作为物联网节点&#xff0c;实现物联网应用。同时掌控板上集成了OLED…

Docker与DevOps的无敌组合,引爆你的创新潜能

&#x1f3c6;荣誉认证&#xff1a;51CTO博客专家博主、TOP红人、明日之星&#xff1b;阿里云开发者社区专家博主、技术博主、星级博主。 &#x1f4bb;微信公众号&#xff1a;iOS开发上架 &#x1f4cc;本文由iOS开发上架原创&#xff01; &#x1f389;欢迎关注&#x1f50e;…