02、Python从入门到癫狂：函数与资料容器

news/2025/9/25 19:44:40/文章来源:https://www.cnblogs.com/lxjshuju/p/19111868

02、Python从入门到癫狂：函数与资料容器

Python函数与数据容器

一、函数

1、语法及定义

函数:是组织好的，可重复使用的，用来实现特定功能的代码段，
##语法
def 函数名(入参):
函数体
return 返回值
调用
函数名(参数)
##如果函数没有使用return语句返回数据，那么函数有返回值吗?
实际上是:有的。Python中有一个特殊的字面量:None，其类型是:<class'NoneType'>无返回值的函数，实际上就是返回了:None这个字面量## 在if判断中 None等同于False## None可以用于声明一些无初始值的变量
eg:
def my_str(str):
count = 0;
for i in str:
count = count + 1;
return count;
str_1 = "我是一个字符串";
str_2 = "我是另一个字符串";
print(f"我的长度是{my_str(str_1)}");
print(f"我的长度是{my_str(str_2)}");
##函数说明
"""
函数说明
:param x: 参数x的说明
:param y: 参数y的说明
:return:  返回值的说明
"""
eg:
def my_add(x,y):
"""
计算两个数的和
:param x: 第一个数
:param y: 第二个数
:return: 两个数的和
"""
return x + y;
print(my_add(1,2))

2、函数的多返回值

"""
函数的多返回值
"""
def multReturn():
return 1,"hello";
x,y = multReturn();
print(f"函数的第一个返回值是:{x},第二个返回值是:{y}")

3、函数的多中传参方式

##位置参数
位置参数:调用函数时根据函数定义的参数位置来传递参数
def userInfo1(name,age,email):
print(f"姓名：{name},年龄：{age},邮箱{email}")
userInfo1("张三",18,"张三@126.com")
##关键字参数
关键字参数:函数调用时通过 键=值 形式传递参数.
作用:可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求
def userInfo1(name,age,email):
print(f"姓名：{name},年龄：{age},邮箱{email}")
userInfo1(email="lisi@126.com",name="李四",age=20)
userInfo1("王五",email="wangwu@126.com",age=30)
##缺省参数
缺省参数:缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值
(注意:所有位置参数必须出现在默认参数前，包括函数定义和调用)
（带默认值的参数必须定义在所有无默认值参数的后面）
作用:当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
def userInfo2(name,email,age=20):
print(f"姓名：{name},年龄：{age},邮箱{email}")
userInfo2("刘六","liuliu@126.com")
userInfo2("赵七","zhaoqi@126.com",17)
##不定长参数
不定长参数:不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
作用:当调用函数时不确定参数个数时，可以使用不定长参数
·位置传递
传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一元组(tuple)
args是元组类型，这就是位置传递
def userInfo3(*args):
print(f"位置不定长的参数{args}")
userInfo3("张三",99,"male")
·关键字传递
参数是“键=值”形式的形式的情况下，所有的“键=值”都会被kwargs接受，同时会根据“键=值”组成字典
def userInfo4(**args):
print(args)
userInfo4(name="Tom",age="18",id="99")

4、匿名函数

·函数也可以作为另一个函数的参数传递
·将函数传入的作用：传入计算逻辑，而非传入数据
def test_func(calculate):
result = calculate(5,2)
return result;
def add(x,y):
return x+y;
def sub(x,y):
return x-y;
res = test_func(add)
print(f"函数计算结果{res}");

5、lambda匿名函数

##语法
lambda 传入参数:函数体(一行代码)
·lambda是关键字表示匿名函数
def test_func(calculate):
result = calculate(5,2)
return result;
res = test_func(lambda x,y:x*y);
print(f"函数的计算结果{res}");

二、变量的作用域

变量作用域指的是变量的作用范围(变量在哪里可用，在哪里不可用).
主要分为两类:局部变量和全局变量
局部变量的作用:在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量
全局变量，指的是在函数体内、外都能生效的变量
eg:
num = 0;
def my_print1():
print(f"我是my_print1,num={num}")
def my_print2():
print(f"我是my_print2,num={num}")
my_print1();
my_print2();
print(num);
##global关键字
设置内部定义的变量为全局变量
"""
全局变量2
"""
num = 0;
def my_add1():
global num;
num = +1;
print(f"我是my_add1,num={num}")
print(num)
def my_add2():
global num;
num=+2;
print(f"我是my_add2,num={num}")
my_add1();
my_add2();
print(num);
"""
全局变量2
"""
num = 0;
def my_add1():
global num;
num += 1;
print(f"我是my_add1,num={num}")
print(num)
def my_add2():
global num;
num+=2;
print(f"我是my_add2,num={num}")
my_add1();
my_add2();
print(num);
##理解上面两个例子  num=+1 和num+=1的区别
num += 1 的意思是：把 num 的值加 1
num = +1 的意思是：把 num 设置为 +1（也就是正数 1）

三、数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等.
##数据容器包含5类
列表-list 元组-tuple  字符串-str 集合-set 字典-dict

1、list列表

##语法
# 字面量
[元素1，元素2，元素3，元素4，...]
# 定义变量
变量名称 =[元素1，元素2，元素3，元素4，...]
# 定义空列表
变量名称 =[]
变量名称 = 1ist()
##注意：
列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
嵌套： [[元素1,元素2],[元素a,元素b]]
正向索引：从0开始数
负向索引：从-1开始数
##属性
·列表容纳上线2**63 - 1
·可以容纳不同类型的元素
·有序存储（有脚标）
·允许重复数据的存在
·可以修改（增加、修改、删除元素等）
eg:
province = ['北京', '上海', '广州', '深圳']
print(province)
print(type(province))
print("=================")
other = [1, "你好", 3.1, True, None]
print(other)
print(type(other))
print("=================")
##常用操作
##1、查询功能
列表.index(元素)   查询指定元素在列表的下标（找不到报错ValueError）
##2、修改功能
列表[下标] = 新值
##3、插入功能
列表.insert(下标、元素)  在指定的下标位置，插入指定的元素
##4、追加功能
列表.append(元素)   将指定的元素，追加到列表的尾部
列表.extend(其他容器)  将指定容器里的内容，批量增加到列表的尾部
##5、删除元素
del 列表[下标]   删除指定下标位置的元素
列表.pop(下标)   删除指定下标位置的元素
##6、删除第一个匹配项
列表.remove(元素) 删除列表中对指定元素的第一个匹配项
##7、清空列表
列表.clear()
##8、统计元素数量
列表.count(元素)
##9、统计列表的元素总数
len(列表)
编号使用方式作用
1列表.append(元素)向列表中追加一个元素
2列表.extend(容器)将数据容器的内容依次取出，追加到列表尾部
3列表.insert(下标, 元素)在指定下标处，插入指定的元素
4del 列表[下标]删除列表指定下标元素
5列表.pop(下标)删除列表指定下标元素
6列表.remove(元素)从前向后，删除此元素第一个匹配项
7列表.clear()清空列表
8列表.count(元素)统计此元素在列表中出现的次数
9列表.index(元素)查找指定元素在列表的下标 找不到报错ValueError
10len(列表)统计容器内有多少元素
"""
列表-常用操作
"""
mylist = [1,2,3,4,5,6];
#1、查询
second = mylist[1];
print(f"列表的第二个元素是：{second
}")
##2、修改
mylist[1] = 100;
print(f"修改后的列表是：{mylist
}")
##3、插入
mylist.insert(1,"t2");
print(f"插入后的列表是：{mylist
}")
#4、追加
mylist.append("t7");
print(f"追加后的列表是：{mylist
}")
extendList = [7,8,9];
mylist.extend(extendList);
print(f"追加后的列表是：{mylist
}")
##5、删除元素
del mylist[1];
print(f"删除后的列表是：{mylist
}")
del mylist[1];
print(f"删除后的列表是：{mylist
}")
popEle = mylist.pop(1);
print(f"删除后的列表是：{mylist
}，弹出的元素是：{popEle
}")
##6、统计指定元素数量
count = mylist.count("t7");
print(f"列表中100的数量是：{count
}")
##7、统计元素总数
length = len(mylist);
##列表的遍历
"""
while循环遍历列表
"""
##定义一个函数
def whilePrintList(tmplist):
##判断是否是列表
if type(tmplist) != list:
print("参数不是列表")
else:
index = 0;
while index <
len(tmplist):
print(f"第{index
}个元素是：{tmplist[index]
}");
index += 1;
myList1 = [1,2,3,4,5,6];
whilePrintList(myList1);
print("=========================================")
"""
for循环遍历列表
"""
def forPrintList(tmplist):
#判断是否是列表
if type(tmplist) != list:
print("参数不是列表")
else:
index =0;
for ele in tmplist:
print(f"第{index
}个元素是：{ele
}")
index += 1;
myList2 = ["a1","a2","a3","a4","a5","a6"];
forPrintList(myList2);

2、tuple元组

##定义
# 定义元组字面量
(元素，元素，.....元素)
#定义元组变量
变量名称 = (元素，元素，......元素)
#定义空元组
变量名称 = ()
变量名称 = tuple()
# 方式1# 方式2
##属性
·元组同列表一样，都可以封装多个、不同类型的元素
·列表使用[]中括号定义,元组使用()小括号定义
·元组一旦定义完成，就不可以修改(但是可以修改内部list的内部元素)
##注意
如果元组内定义了一个list，那么元组里的list是可以修改的
eg:
##元组的定义
t1 = (1,2,3,4,5,6);
t2 = ();
t3 = tuple();
print(f"t1的类型是：{
type(t1)
},内容是：{t1
}")
print(f"t2的类型是：{
type(t2)
},内容是：{t2
}")
print(f"t4的类型是：{
type(t3)
},内容是：{t3
}")
##定义单个元组
t4 = ("元素1");
#它的类型其实是字符串
print(f"t4的类型是：{
type(t4)
},内容是：{t4
}")
t5 = ("元素2",);
#定义单个元组时，必须要在元素后面添加逗号
print(f"t5的类型是：{
type(t5)
},内容是：{t5
}")
##嵌套元组
t6 =((1,2,3),("a","b","c"));
print(f"t6的类型是：{
type(t6)
},内容是：{t6
}")
##从嵌套元组中获取元素
num = t6[1][2]
print(f"t6中嵌套的元组的[1][2]元素是：{num
}")
编号方法作用
1index()查找某个数据，如果数据存在返回对应的下标，否则报错
2count()统计某个数据在当前元组出现的次数
3len(元组)统计元组内的元素个数
##元组的长度
print(f"t6的长度是：{
len(t6)
}")
##元组的指定元素下标
indexNum = t1.index(3);
print(f"t1中元素3的下标是：{indexNum
}")
##元组的数量
countNum = t1.count(2);
print(f"t1中元素3的数量是：{countNum
}")
"""
tuple的例外修改
"""
##元组里的list是可以修改的
t7 = (1,2,3,["A","B"]);
print(f"t7的类型是：{
type(t7)
},内容是：{t7
}")
t7[3][0] = "C";
print(f"t7的类型是：{
type(t7)
},内容是：{t7
}")

3、str字符串

字符串是字符的容器，一个字符串可以存放任意数量的字符.
##属性
·字符串是一个不可修改的数据容器 myStr[1]="xx" 这样写会报错
##字符串的下标索引
·从前向后，下标从0开始
·从后向前，下标从-1开始
##元组的定义
t1 = (1,2,3,4,5,6);
t2 = ();
t3 = tuple();
print(f"t1的类型是：{
type(t1)
},内容是：{t1
}")
print(f"t2的类型是：{
type(t2)
},内容是：{t2
}")
print(f"t4的类型是：{
type(t3)
},内容是：{t3
}")
##定义单个元组
t4 = ("元素1");
#它的类型其实是字符串
print(f"t4的类型是：{
type(t4)
},内容是：{t4
}")
t5 = ("元素2",);
#定义单个元组时，必须要在元素后面添加逗号
print(f"t5的类型是：{
type(t5)
},内容是：{t5
}")
##嵌套元组
t6 =((1,2,3),("a","b","c"));
print(f"t6的类型是：{
type(t6)
},内容是：{t6
}")
##从嵌套元组中获取元素
num = t6[1][2]
print(f"t6中嵌套的元组的[1][2]元素是：{num
}")
"""
tuple常用操作
"""
##元组的长度
print(f"t6的长度是：{
len(t6)
}")
##元组的指定元素下标
indexNum = t1.index(3);
print(f"t1中元素3的下标是：{indexNum
}")
##元组的数量
countNum = t1.count(2);
print(f"t1中元素3的数量是：{countNum
}")
"""
tuple的例外修改
"""
##元组里的list是可以修改的
t7 = (1,2,3,["A","B"]);
print(f"t7的类型是：{
type(t7)
},内容是：{t7
}")
t7[3][0] = "C";
print(f"t7的类型是：{
type(t7)
},内容是：{t7
}")
##常用方法
1、查询位置
字符串.index()
2、替换指定字符  (得到的是一个新的字符串而不是在原来的基础上修改)
新的字符串 = 字符串.replace("xxx")
3、字符串分割  (得到的是一个新的字符串而不是在原来的基础上修改)
列表 = 字符串.split("xxx")
4、字符串的规整操作
新字符串 = 字符串.trip()   #去除字符串的前后空格
新字符串 = 字符串.trop(字符串2)  #按照字符串2中的单个字符一处 字符串中存在的(只针对开始和结束)
5、统计次数
字符串.count(内容)
6、字符串长度
len(字符串)
#1、修改（不可修改）
# str = "hello world";
# str[1] = "a";
# print(f"str的类型是：{type(str)},内容是：{str}")
#2、查找
str = "hello world";
num = str.index("l");
print(f"str中元素l的下标是：{num
}")
##替换
newStr = str.replace("lo","a");
print(f"str替换后的内容是：{newStr
},替换前的内容是：{
str
}")
##字符串分割
newStrList = str.split(" ");
print(f"str分割后的内容是：{newStrList
},类型是：{
type(newStrList)
}")
##字符串规整
str = " hello world ";
str = str.strip();
print(f"str规整后的内容是：{
str
}")
str = "12 hello 12 world 21";
str = str.strip("12");
print(f"str规整后的内容是：{
str
}")
##统计出现次数
num = str.count("l");
print(f"str中元素l的出现次数是：{num
}")
##统计长度
num = len(str);
print(f"str的长度是：{num
}")

4、数据容器（序列）切片

序列是指:内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。

在这里插入图片描述

语法:序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列:
·起始下标表示从何处开始，可以留空，留空视作从头开始
·结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
·步长表示，依次取元素的间隔
··步长1表示，一个个取元素
··步长2表示，每次跳过1个元素取
··步长N表示，每次跳过N-1个元素取
··步长为负数表示，反向取(注意，起始下标和结束下标也要反向标记)
##注意
对序列的切片不会影响到序列本身，而会产生一个新的序列
#1、list切片
my_list = [1,2,3,4,5,6,7,8,9];
result= my_list[1:5];
print(f"my_list[1:5]的结果是：{result
}")
#2、元组切片
my_list = (1,2,3,4,5,6,7,8,9);
result= my_list[1:5:2];
print(f"my_list[1:5:2]的结果是：{result
}")
#3、字符串切片
str = "hello world";
result = str[0:10:3];
print(f"str[0:10:3]的结果是：{result
}")
###结果打印：
my_list[1:5]的结果是：[2, 3, 4, 5]
my_list[1:5:2]的结果是：(2, 4)
str[0:10:3]的结果是：hlwl

5、Set集合

##语法
# 定义集合字面量
{元素,元素,元素}
# 定义集合变量
变量名称 ={元素，元素，......元素}
#定义空集合
变量名称 = set()
##属性
·不支持元素的重复
·内容无序
·不允许下标索引访问
#1、集合的创建
my_set1 = {
1,2,3,4,5,6,7,8,9
};
print(f"my_set1的类型是：{
type(my_set1)
},内容是：{my_set1
}")
my_set2 = set();
print(f"my_set2的类型是：{
type(my_set2)
},内容是：{my_set2
}")
##常用操作
1、添加元素
集合.add(元素)
2、移除元素
集合.remove(元素)
3、随机移除一个元素
集合.pop()
4、清空集合
集合.clear()
5、取两个集合的差集
（集合1有 而 集合2 没有的，集合1和集合2不变 得到一个新集合）（即去除公共部分的元素）
集合 = 集合1.difference(集合2)
6、消除两个集合的差集
（从集合1中 删除 集合2 中包含的元素）（集合1变化、集合2不变）
集合1.difference_update(集合2)
7、合并集合
(合并两个集合的数据，得到一个新集合,集合1和集合2不变)
集合 = 集合1.union(集合2)
8、两个集合的交集
集合 = 集合1.intersection(集合2)
集合 = 集合1 & 集合2
#1、集合的添加
my_set3 = {
"语文","数学","英语"
};
my_set3.add("物理");
print(f"my_set3添加物理后的结果是：{my_set3
}")
my_set3.add("语文")
print(f"my_set3添加语文后的结果是：{my_set3
}")
#2、集合的删除
my_set3.remove("语文")
print(f"my_set2删除语文后的结果是：{my_set3
}")
##3、随机删除一个集合
my_set3.pop()
print(f"my_set3随机删除一个元素后的结果是：{my_set3
}")
##4、清空集合
my_set3.clear()
print(f"my_set3清空后的结果是：{my_set3
}")
##5、集合的长度
print(f"my_set3的长度是：{
len(my_set3)
}")
##6、取两个集合的差集
my_set5 = {
1,2,3
}
my_set6 = {
2,3,4
}
newset = my_set5.difference(my_set6);
print(f"my_set5和my_set6的差集是：{newset
},my_set5的内容是：{my_set5
},my_set6的内容是：{my_set6
}")
##7、消除两个集合的差集
my_set5.difference_update(my_set6);
print(f"my_set5和my_set6的差集消除后的结果是：{my_set5
},my_set6的内容是：{my_set6
}")
##8、取两个集合的并集
my_set5 = {
1,2,3
}
my_set6 = {
2,3,4
}
newset = my_set5.union(my_set6);
print(f"my_set5和my_set6的并集是：{newset
},my_set5的内容是：{my_set5
},my_set6的内容是：{my_set6
}")
##9、取两个集合的交集
newset = my_set5.intersection(my_set6);
print(f"my_set5和my_set6的交集是：{newset
},my_set5的内容是：{my_set5
},my_set6的内容是：{my_set6
}")
newset = my_set5 & my_set6;
print(f"my_set5和my_set6的交集是：{newset
},my_set5的内容是：{my_set5
},my_set6的内容是：{my_set6
}")
##10、集合遍历
my_set3 = {
"语文","数学","英语"
};
for ele in my_set3:
print(f"集合my_set3的元素是：{ele
}")
####结果打印：
my_set3添加物理后的结果是：{
'英语', '物理', '语文', '数学'
}
my_set3添加语文后的结果是：{
'英语', '物理', '语文', '数学'
}
my_set2删除语文后的结果是：{
'英语', '物理', '数学'
}
my_set3随机删除一个元素后的结果是：{
'物理', '数学'
}
my_set3清空后的结果是：set()
my_set3的长度是：0
my_set5和my_set6的差集是：{
1
},my_set5的内容是：{
1, 2, 3
},my_set6的内容是：{
2, 3, 4
}
my_set5和my_set6的差集消除后的结果是：{
1
},my_set6的内容是：{
2, 3, 4
}
my_set5和my_set6的并集是：{
1, 2, 3, 4
},my_set5的内容是：{
1, 2, 3
},my_set6的内容是：{
2, 3, 4
}
my_set5和my_set6的交集是：{
2, 3
},my_set5的内容是：{
1, 2, 3
},my_set6的内容是：{
2, 3, 4
}
my_set5和my_set6的交集是：{
2, 3
},my_set5的内容是：{
1, 2, 3
},my_set6的内容是：{
2, 3, 4
}
集合my_set3的元素是：语文
集合my_set3的元素是：英语
集合my_set3的元素是：数学

6、dict字典

##语法
#定义字典字面量
{key:value, key:value,......,key: value}
# 定义字典变量
my_dict = {key: value, key: value,key: value...}
# 定义空字典
my_dict ={}
my_dict = dict()
##属性
·字典的key不可以重复
·字典的key和value可以是任意数据类型（key不可以是字典）
eg:
##1、字典的定义
my_dict1 = {
"name":"张三","age":18,"gender":"男"
};
my_dict2 = {
};
my_dict3 = dict();
print(f"字典my_dict1的内容是:{my_dict1
},类型是{
type(my_dict1)
}");
print(f"字典my_dict2的内容是:{my_dict2
},类型是{
type(my_dict2)
}");
print(f"字典my_dict3的内容是:{my_dict3
},类型是{
type(my_dict3)
}");
##2、嵌套的字典
my_dict4 = {
"张三":{
"语文":90,
"数学":80,
"英语":70
},
"李四":{
"语文":80,
"数学":90,
"英语":85
}
}
print(f"字典my_dict4的内容是:{my_dict4
},类型是{
type(my_dict4)
}");
##常用的操作
1、字典值的获取
字典[key]
2、新增元素
字典[key] = value
3、修改元素 (key是不可以重复的)
字典[key] = value
4、删除元素
字典.pop(key)
del 字典[key]
5、清空
字典.clear()
6、获取全部key
字典.keys()
7、获取全部value
字典.values()
8、计算字典中元素数量
len(字典)
"""
字典常用操作
"""
##1、获取字典的值
name = my_dict1["name"];
print(f"字典my_dict1的name值是:{name
}");
score = my_dict4["张三"]["语文"];
print(f"字典my_dict4的张三的语文成绩是:{score
}");
##2、获取字典的所有键
keys = my_dict1.keys();
print(f"字典my_dict1的所有键是:{keys
},类型是{
type(keys)
}");
##3、新增
my_dict1["email"] = "zhangsan@qq.com";
print(f"字典my_dict1的内容是:{my_dict1
}");
##4、修改
my_dict1["name"] = "张三三";
print(f"字典my_dict1的内容是:{my_dict1
}");
##5、删除
del my_dict1["email"];
print(f"字典my_dict1的内容是:{my_dict1
}");
my_dict1.pop("gender");
print(f"字典my_dict1的内容是:{my_dict1
}");
##6、清空字典
my_dict1.clear();
print(f"字典my_dict1的内容是:{my_dict1
}");
##7、遍历字典
my_dict5 = {
"语文":90,"数学":80,"英语":70
};
for key in my_dict5.keys():
print(f"字典my_dict5的键是:{key
},值是:{my_dict5[key]
}");
for key in my_dict5:
print(f"字典my_dict5的键是:{key
},值是:{my_dict5[key]
}");
##8、获取字典的所有值
values = my_dict5.values();
print(f"字典my_dict5的所有值是:{values
},类型是{
type(values)
}");
##9、获取字典的元素数量
num = len(my_dict5);
print(f"字典my_dict5的元素数量是:{num
}");

7、容器对比

特性/数据结构列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意任意仅字符任意Key: Value
Key：除字典外任意类型
Value：任意类型
下标索引支持支持支持不支持不支持
重复元素支持支持支持不支持不支持
可修改性支持不支持不支持支持支持
数据有序是是是否否
使用场景可修改、可重复的一批数据记录场景不可修改、可重复的一批数据记录场景一串字符的记录场景不可重复的数据记录场景以Key检索Value的数据记录场景

8、容器的通用操作

1、统计容器的元素个数
len(容器)
2、统计容器的最大元素
max(容器)
3、统计容器的最小元素
min(容器)
4、容器转列表
list(容器)
5、容器转元组
tuple(容器)
6、容器转字符串
str(容器)
7、容器转集合
set(容器)
8、排序功能 （排完序后都是列表）
sorted(容器,[reverse=True])   reverse默认False从小到大，True为从大到小

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

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

相关文章

9/25

9/25

今天学了算法数结构，学了许多与线性表相关的知识。
阅读更多...
社区服务呼叫系统 网站的建设网站效果图设计

社区服务呼叫系统 网站的建设网站效果图设计

提供帧动画组件来实现逐帧播放图片的能力&#xff0c;可以配置需要播放的图片列表&#xff0c;每张图片可以配置时长。 说明&#xff1a; 该组件从API Version 7开始支持。后续版本如有新增内容&#xff0c;则采用上角标单独标记该内容的起始版本。 子组件 无 接口 ImageAni…
阅读更多...
关闭Edge浏览器页面的圆角效果

关闭Edge浏览器页面的圆角效果

起因 edge浏览器的这个圆角我看着不太习惯 ，特别是在看一些博客文章的时候 ，总感觉不太舒服 ，所以想给他关闭掉关闭或者开启设置在浏览器搜索框输入edge://flags然后再在页面的搜索框中输入Microsoft Edge rounded …
阅读更多...
搜索二维矩阵II-leetcode

搜索二维矩阵II-leetcode

题目描述 编写一个高效的算法来搜索 *m* x *n* 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：每行的元素从左到右升序排列。 每列的元素从上到下升序排列。示例 1：输入：matrix = [[1,4,7,11,15],[2,5,8…
阅读更多...
Rust/C/C++ 混合构建 - Cmake集成Cargo编译动态库

Rust/C/C++ 混合构建 - Cmake集成Cargo编译动态库

Cmake是一个强大的多语言编译工具，其内置模块提供了强大的扩展能力。 Rust官方的构建工具是Cargo，其提供了依赖下载，上传和编译等多项功能，极大的便利了Rust项目的开发。 目前C++多数用Cmake构建，如果是Rust集成c…
阅读更多...
小型公司网站建设知乎济南网站建设网站建设

小型公司网站建设知乎济南网站建设网站建设

文章目录 1. Kubernetes的网络类别2. Kubernetes的接口类型3. CNI网络插件 ---- Flannel的介绍及部署3.1 简介3.2 flannel的三种模式3.3 flannel的UDP模式工作原理3.4 flannel的VXLAN模式工作原理3.5 Flannel CNI 网络插件部署3.5.1 上传flannel镜像文件和插件包到node节点3.5.…
阅读更多...
织梦网站图片一直转圈品质好物推荐

织梦网站图片一直转圈品质好物推荐

AOP(Aspect Oriented Programming)&#xff0c;面向切面编程&#xff0c;他是一种编程范式。 作用&#xff1a; 在不改变原始设计的的基础上对其进行功能增强。 几个基本概念&#xff1a; 连接点&#xff1a;所有的方法 切入点&#xff1a;追加功能的方法 通知&#xff1a;追加…
阅读更多...
LangChain：LLMs和ChatModels介绍、LangChain 集成大模型的本地部署与 API 调用实践、提示词prompt、输出解析器、链 - 实践

LangChain：LLMs和ChatModels介绍、LangChain 集成大模型的本地部署与 API 调用实践、提示词prompt、输出解析器、链 - 实践

pre { white-space: pre !important; word-wrap: normal !important; overflow-x: auto !important; display: block !important; font-family: "Consolas", "Monaco", "Courier New", …
阅读更多...
卓伊凡的第一款独立游戏-unity安装运行设置以及熟悉整体unity游戏开发和unity editor【02】-优雅草卓伊凡

卓伊凡的第一款独立游戏-unity安装运行设置以及熟悉整体unity游戏开发和unity editor【02】-优雅草卓伊凡

卓伊凡的第一款独立游戏-unity安装运行设置以及熟悉整体unity游戏开发和unity editor【02】-优雅草卓伊凡2025-09-25 19:26 tlnshuju 阅读(0) 评论(0) 收藏 举报pre { white-space: pre !important; word-wrap: no…
阅读更多...
学习敏捷课程PSM，自考证书分享

学习敏捷课程PSM，自考证书分享

PSM课程自考体会心得​ 一直以来，我都对Scrum比较感兴趣，但真正检验自己对Scrum框架的掌握程度，是从准备 PSM（Professional Scrum Master）认证考试 开始的。相比参加培训班，我选择了自考的方式，这段学习过程对我…
阅读更多...
详细介绍：基于卷积神经网络的人车识别技术：从原理突破到场景重构的深度探索

详细介绍：基于卷积神经网络的人车识别技术：从原理突破到场景重构的深度探索

pre { white-space: pre !important; word-wrap: normal !important; overflow-x: auto !important; display: block !important; font-family: "Consolas", "Monaco", "Courier New", …
阅读更多...
长春 万网 网站建设中国咨询公司排名50强

长春 万网 网站建设中国咨询公司排名50强

本文是我在学习过程中记录学习的点点滴滴&#xff0c;目的是为了学完之后巩固一下顺便也和大家分享一下&#xff0c;日后忘记了也可以方便快速的复习。 网络工程师从入门到入狱 前言一、Wlan应用实战1.1、拓扑图详解1.2、LSW11.3、AC11.4、抓包1.5、Tunnel隧道模式解析1.6、AP、…
阅读更多...
专题定制网站建设工信部网站原来是

专题定制网站建设工信部网站原来是

创建测试用例和测试结果集文件夹&#xff1a; excel编写的接口测试用例如下&#xff1a; 1 encoding 响应的编码格式。所测项目大部分是utf-8&#xff0c;有一个特殊项目是utf-8-sig 2 params 对应requests的params 3 data&#xff0c;对应requests的data 有些参数是动态的&a…
阅读更多...
Rust/C/C++ 混合构建 - 用Bazel构建Rust与C

Rust/C/C++ 混合构建 - 用Bazel构建Rust与C

Bazel是什么 Bazel 是一个类似于 Make、Maven 和 Gradle 的开源构建和测试工具。 它使用人类可读的高级 build 语言。Bazel 支持 并针对多个平台构建输出。Bazel 支持 多个代码库和大量用户的大型代码库。 优势 Bazel …
阅读更多...
9.24(补)

9.24(补)

上午离散数学学的有点意思，下课后看了一眼，马哲的老师讲的也挺有意思的，重点讲了会生产力和生产资料，下午到没干什么，躺了。
阅读更多...
9月25号

9月25号

上午进行了程序语言和数据结构。 然后进行了篮球课。 下午进行了乒乓课。
阅读更多...
有什么好的设计网站自己怎做网站后台

有什么好的设计网站自己怎做网站后台

所谓关联式容器&#xff0c;观念上类似关联式数据库(实际上则简单许多)&#xff1a;每笔数据(每个元素)都有一个键值(key)和一个实值(value) 2。当元素被插入到关联式 容器中时&#xff0c;容器内部结构(可能是RB-tree,也可能是hash-table)便依照其键 值大小&#xff0c;以某种…
阅读更多...
南昌市新农村建设网站聊城专业网站设计公司

南昌市新农村建设网站聊城专业网站设计公司

小A是一名刚刚毕业的算法工程师&#xff0c;有一天&#xff0c;他被老板安排了一个活&#xff0c;要对一批合同扫描件进行自动化信息抽取&#xff0c;输出结构化的分析报表。OCR问题不大&#xff0c;但是怎么进行批量的结构化信息抽取呢&#xff1f;小A陷入了苦苦思索… 小B是…
阅读更多...
CCF CSP-J 2025_from_黄老师_d

CCF CSP-J 2025_from_黄老师_d

2025 CCF CSP-J 入门级（C++）第一轮试题解析 一、单项选择题（每题2分，共30分） 1. 32位无符号整数最大值问题答案：A 分析：32位无符号整数的取值范围是0到(2{32}-1)。计算可得(2=4294967296)，则(2^{32}-1 = 42949…
阅读更多...
亚马逊与AWS如何通过漏洞赏金计划构建深度安全防御

亚马逊与AWS如何通过漏洞赏金计划构建深度安全防御

本文介绍亚马逊和AWS如何通过HackerOne平台的漏洞赏金计划，与全球安全研究人员合作持续测试平台安全性，保护客户数据并促进知识共享，展现企业级安全防御的最佳实践。HackerOne客户案例：亚马逊与AWS 对于亚马逊和AW…
阅读更多...
最新文章

Copyright @ 2022~2023