当前位置: 首页 > news >正文

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.hskmm.com/?act=detail&tid=17281

相关文章:

  • 第二周第四天2.4
  • 9/25
  • 关闭Edge浏览器页面的圆角效果
  • 搜索二维矩阵II-leetcode
  • Rust/C/C++ 混合构建 - Cmake集成Cargo编译动态库
  • 第12章 day13 关于json请求体
  • CF1349
  • 学习敏捷课程PSM,自考证书分享
  • Rust/C/C++ 混合构建 - 用Bazel构建Rust与C
  • 9.24(补)
  • 9月25号
  • CCF CSP-J 2025_from_黄老师_d
  • 亚马逊与AWS如何通过漏洞赏金计划构建深度安全防御
  • sync.pool 面试题
  • 【JavaEE】SpringIoC与SpringDI - 详解
  • 24.Linux硬盘分区管理 - 详解
  • CCF CSP-J 2025_from_黄老师_km
  • AI一周资讯 250918-250925
  • 云栖小镇现场追踪!触摸AI 未来
  • AT_arc154_d [ARC154D] A + B C ?
  • SQL注入-联合注入
  • JVM对象创建与内存分配
  • 目录
  • 交互:在终端中输入用户信息
  • 电脑迁移技巧:适用于 Windows 10/11 的免费磁盘克隆优秀的工具
  • Java学习日记9.18
  • 一种CDN动态加速首次访问加速方法
  • 9.25
  • 字典
  • CF1716题解