pyspark学习-spark.sql.functions 聚合函数

https://spark.apache.org/docs/3.4.1/api/python/reference/pyspark.sql/functions.html
1. approx_count_distinct和count_distinct
#approx_count_distinct(col:ColumnOrName,rsd:Optionnal[float]=None)
"""
作用:返回列col的近似不同计数，返回一个新的列
场景:处理大数据计算时，获得一个精确结果开销很大，但是计算一个近似结果相对容易，此时可以使用approx_count_distinct函数
参数:col:列名rsd:结果允许的误差值，默认0.05
返回:column:返回计算结果列"""
#count_distinct(col:columnOrName)
"""
作用:返回列col不同计数，返回一个新的列
场景:获得一个列准确的不同元素的个数
参数:col:列名
返回：column:返回计算结果列
"""
TEST_DATA_DIR = "/opt/software/tmp/"
def write(filename,data):with open(TEST_DATA_DIR+filename,'wt',encoding='utf-8') as f:f.write(data)def generate_test_file():filename = "test.txt"#初始datadata = ""data_format = "{} {} {}\n"#分别存放id,name,score 随机生成100000条数据，统计score列不同数量for i in range(100000):data += data_format.format(i+1,'jack'+str(i),random.randint(0,100))write(filename,data=data)
if __name__ == '__main__':generate_test_file()spark = SparkSession.builder.getOrCreate()schema = StructType([StructField("id",StringType(),True),StructField("name",StringType(),True),StructField("score",StringType(),True)])#读取文件data = spark.sparkContext.textFile(TEST_DATA_DIR+'test.txt').map(lambda x:x.split(' ')).map(lambda x:Row(x[0],x[1],x[2]))gradeDF=spark.createDataFrame(data,schema=schema)gradeDF.select(approx_count_distinct('score',rsd=0.01)).show()gradeDF.select(count_distinct('score')).show()#输出结果
"""很明显是数据存在误差
+----------------------------+
|approx_count_distinct(score)|
+----------------------------+
|                          99|
+----------------------------++---------------------+
|count(DISTINCT score)|
+---------------------+
|                  101|
"""
+---------------------+
2. collect_list和collect_set:列转行
#collect_list(col:ColumnOrName)
"""
作用:返回col列的list副本，该函数返回值顺序不确定
场景:列转行
参数:col:列名
返回:column:返回col列的list副本
"""
#collect_set(col:ColumnOrName)
"""
作用:返回col列的set副本，该函数返回值顺序不确定
场景:列转行
参数:col:列名
返回:column:返回col列的set副本
"""
spark = SparkSession.builder.getOrCreate()#20110101销售商品数据
data = spark.createDataFrame([['20110101','A',22],['20110101','B',22],['20110102','A',33]],schema=['rq','produce_type','sl'])  #data.show()data.createOrReplaceTempView("data")spark.sql("select rq,collect_list(sl) as collect_list from data group by rq").show()spark.sql("select rq,collect_set(sl) as collect_set from data group by rq").show()
#输出结果
"""
+--------+------------+---+
|      rq|produce_type| sl|
+--------+------------+---+
|20110101|           A| 22|
|20110101|           B| 22|
|20110102|           A| 33|
+--------+------------+---++--------+------------+
|      rq|collect_list|
+--------+------------+
|20110101|    [22, 22]|
|20110102|        [33]|
+--------+------------++--------+-----------+
|      rq|collect_set|
+--------+-----------+
|20110101|       [22]|
|20110102|       [33]|
+--------+-----------+
"""
3. corr:皮尔逊相关性
#corr(col1:ColumnOrName,col2:ColumnOrName)
"""
作用:返回col1列和col2列的皮尔逊相关系数
场景:
参数:col1:列名col2:列名
返回:column:返回col1列和col2列的皮尔逊相关系数
"""
spark = SparkSession.builder.getOrCreate()
a = range(20)
b = [2 * x for x in a]
data = spark.createDataFrame(zip(a,b),schema=['a','b'])
data.agg(corr('a','b').alias('c')).show()
data.createOrReplaceTempView("data")
spark.sql("select corr(a,b) as c from data").show()
#输出结果
"""
+---+
|  c|
+---+
|1.0|
+---++---+
|  c|
+---+
|1.0|
+---+
"""
4. covar_pop和covar_sample:返回列的总体协方差和样本协方差
#covar_pop(col1:ColumnOrName,col2:ColumnOrName)
"""
作用:返回col1列和col2列的总体协方差
场景:
参数:col1:列名col2:列名
返回:column:返回col1列和col2列的协方差
公式:u0：x平均值  u1:y平均值cov(x,y) = ((x1-u0)*(y1-u1)+(x2-u0)*(y2-u1)+...+(xN-u0)*(yN-u1))/N
例子:X = [1,2,3]  Y = [3,6,9]   u = 2            u = 6cov(x,y) = ((1-2)*(3-6)+(2-2)*(6-6)+(3-2)*(6-9))/3 = 2
"""
#cover_samp(col1:ColumnOrName,col2:ColumnOrName)
"""
作用:返回col1列和col2列的样本协方差
场景:
参数:col1:列名col2:列名
返回:column:返回col1列和col2列的样本协方差
公式:u0：x平均值  u1:y平均值cov(x,y) = ((x1-u0)*(y1-u1)+(x2-u0)*(y2-u1)+...+(xN-u0)*(yN-u1))/(N-1)
例子:X = [1,2,3]  Y = [3,6,9]   u = 2            u = 6cov(x,y) = ((1-2)*(3-6)+(2-2)*(6-6)+(3-2)*(6-9))/2 = 3"""#总体协方差和样本协方差区别重点是分母不同，总体协方差为N，样本协方差为N-1spark = SparkSession.builder.getOrCreate()
data = spark.createDataFrame([(1,3),(2,6),(3,9)],schema=['a','b'])  
# ((1-2)*(3-6)+(2-2)*(6-6)+(3-2)*(9-6))/3 = 2
data.agg(covar_pop('a','b').alias('covar_pop')).show()
data.agg(covar_samp('a','b').alias('covar_samp')).show() 
#((1-2)*(3-6)+(2-2)*(6-6)+(3-2)*(9-6))/2 = (3+3)/2 = 3
#输出如下:
+---------+
|covar_pop|
+---------+
|      2.0|
+---------++----------+
|covar_samp|
+----------+
|       3.0|
+----------+
5. first:返回集合中第一个元素  last:返回集合中最后一个元素
#first(col:ColumnOrName,ignorenulls:ColumnOrName)
"""
作用:返回该组第一个数值,和groupBy合用，会显示分组之后，各个组的第一个
场景:
参数:col:列名ignorenulls：是否忽略控制
返回:column:返回该组第一个数值
"""
#last(col:ColumnOrName,ignorenulls:ColumnOrName)
"""
作用:返回该组第最后一个数值,和groupBy合用，会显示分组之后，各个组的最后一个
场景:
参数:col:列名ignorenulls：是否忽略控制
返回:column:返回该组第最后一个数值
"""
data = spark.createDataFrame([('Alice',2),('Bob',5),('Alice',12),('Bob',32),('Alice',None)],schema=("name","age"))
print("按照age排序前")
data.groupby('name').agg(first("age")).show()
data.groupby('name').agg(first("age", ignorenulls=True)).show()print("按照age倒排序后")
data = data.orderBy("age",ascending=False)
data.groupby('name').agg(first("age")).show()
data.groupby('name').agg(first("age", ignorenulls=True)).show()#lastdata.groupby('name').agg(last("age")).show()
data.groupby('name').agg(last("age", ignorenulls=True)).show()print("按照age倒排序后")
data = data.orderBy("age", ascending=False)
data.groupby('name').agg(last("age")).show()
data.groupby('name').agg(last("age", ignorenulls=True)).show()#输出如下:
"""
按照age排序前
+-----+----------+
| name|first(age)|
+-----+----------+
|  Bob|         5|
|Alice|         2|
+-----+----------++-----+----------+
| name|first(age)|
+-----+----------+
|  Bob|         5|
|Alice|         2|
+-----+----------+按照age倒排序后
+-----+----------+
| name|first(age)|
+-----+----------+
|  Bob|        32|
|Alice|        12|
"""data = data.sort(data['age'].asc())data.createOrReplaceTempView("data")
spark.sql("select name,first(age) from data  where age >0 group by name ").show()
#输出如下:
"""
+-----+----------+
| name|first(age)|
+-----+----------+
|  Bob|         5|
|Alice|         2|
+-----+----------+#last
+-----+---------+
| name|last(age)|
+-----+---------+
|  Bob|       32|
|Alice|     null|
+-----+---------++-----+---------+
| name|last(age)|
+-----+---------+
|  Bob|       32|
|Alice|       12|
+-----+---------+按照age倒排序后
+-----+---------+
| name|last(age)|
+-----+---------+
|  Bob|        5|
|Alice|     null|
+-----+---------++-----+---------+
| name|last(age)|
+-----+---------+
|  Bob|        5|
|Alice|        2|
+-----+---------+
"""
6. grouping:判断是否聚合
#grouping(col:ColumnOrName)
"""
作用:
场景:
参数:col:列名
返回:column:如果聚合返回1，否则返回0
"""
data = spark.createDataFrame([('Alice', 2), ('Bob', 5), ('Alice', 12), ('Bob', 32)],schema=("name", "age"))
data.cube('name').agg(grouping('name'),count("age")).show()
#输出如下:
"""
data = spark.createDataFrame([('Alice', 2), ('Bob', 5), ('Alice', 12), ('Bob', 32)],schema=("name", "age"))
data.cube('name').agg(grouping('name'),count("age")).show()
"""
7.max\min\mean\median\sum\avg\count\product
"""
max:返回集合中最大元素  
min:返回集合中最小元素  
mean:返回集合元素中平均数  过滤空值
avg:和mean一样            过滤空值
median:返回结合中元素中位数    
sum:返回集合元素中元素之和 
count:返回集合元素个数     过滤空值
product:返回集合中元素的乘积
"""
"""
作用:
场景:
参数:col:列名
返回:column:返回对应结果
"""
#姓名  科目  成绩
data = spark.createDataFrame([('tom','math',32),('tom','english',50),('tom','chinese',90),
('jack','math',62),('jack','english',70),('jack','chinese',80),
('danny','math',92),('danny','english',80),('danny','chinese',70)
],schema=['name','subject','score'])#最大元素
data.groupby('name').agg(max('score')).show()
data.agg(max('score')).show()
#输出如下:
+-----+----------+
| name|max(score)|
+-----+----------+
| jack|        80|
|  tom|        90|
|danny|        92|
+-----+----------++----------+
|max(score)|
+----------+
|        92|
+----------+
#最小元素
data.groupby('subject').agg(min('score')).show()
data.agg(min('score')).show()
#输出如下:
+-----+----------+
| name|min(score)|
+-----+----------+
| jack|        62|
|  tom|        32|
|danny|        70|
+-----+----------++----------+
|min(score)|
+----------+
|        32|
+----------+
#mean平均值
#最大元素
data.groupby('name').agg(mean('score')).show()
data.agg(mean('score')).show()
#输出如下:
+-----+------------------+
| name|        avg(score)|
+-----+------------------+
| jack| 70.66666666666667|
|  tom|57.333333333333336|
|danny| 80.66666666666667|
+-----+------------------++-----------------+
|       avg(score)|
+-----------------+
|69.55555555555556|
+-----------------+
#median中位数
data.groupby('name').agg(median('score')).show()
data.agg(median('score')).show()
#sum求和
data.groupby('name').agg(sum('score')).show()
data.agg(sum('score')).show()
#输出如下:
"""
+-----+----------+
| name|sum(score)|
+-----+----------+
| jack|       212|
|  tom|       172|
|danny|       242|
+-----+----------++----------+
|sum(score)|
+----------+
|       626|
+----------+
"""
#count元素个数
data.groupby('name').agg(count('score')).show()
data.agg(count('score')).show()
#输出如下:
"""
+-----+------------+
| name|count(score)|
+-----+------------+
| jack|           3|
|  tom|           3|
|danny|           3|
+-----+------------++------------+
|count(score)|
+------------+
|           9|
+------------+
"""
#product:返回乘积
data.groupby('name').agg(product('score')).show()
data.agg(product('score')).show()
#输出如下:
+-----+--------------+
| name|product(score)|
+-----+--------------+
| jack|      347200.0|
|  tom|      144000.0|
|danny|      515200.0|
+-----+--------------++--------------+
|product(score)|
+--------------+
|2.575835136E16|
+--------------+
 8. sum_distinct:不同元素求和
#sum_distinct不同元素求和,只有列中元素不同才进行加法运算
"""
作用:
场景:
参数:col:列名
返回:column:返回对应结果
"""
spark = SparkSession.builder.getOrCreate()
data = spark.createDataFrame([('tom', 'math', 32), ('tom', 'english', 32), ('tom', 'chinese', 32), ('jack', 'math', 32), ('jack', 'english', 32), ('jack', 'chinese', 32),
('danny', 'math', 32), ('danny', 'english', 32), ('danny', 'chinese', 32)], schema=['name', 'subject', 'score'])data.groupby('name').agg(sum_distinct('score')).show()
data.agg(sum_distinct('score')).show()
#输出如下:
"""
+-----+-------------------+
| name|sum(DISTINCT score)|
+-----+-------------------+
| jack|                 32|
|danny|                 32|
|  tom|                 32|
+-----+-------------------++-------------------+
|sum(DISTINCT score)|
+-------------------+
|                 32|
+-------------------+
"""
9. var_pop:方差  var_pop:样本方差  variance:方差
#如果数据集合存在空值,则过滤掉,分母也减掉这个元素
#var_pop:返回该列的总体方差
"""
作用:
场景:
参数:col:列名
返回:column:返回对应结果
公式:u:(x1,x2,...,XN)平均数[(x1-u)**2+(x2-u)**2+...+(xN-u)**2]/N
"""#var_samp:返回该列的样本方差
"""
作用:
场景:
参数:col:列名
返回:column:返回对应结果
公式:u:(x1,x2,...,XN)平均数[(x1-u)**2+(x2-u)**2+...+(xN-u)**2]/(N-1)
"""
#variance:方差，公式和var_samp一致
spark = SparkSession.builder.getOrCreate()
data = spark.createDataFrame([('tom', 'math', 1), ('tom', 'english', 2), ('tom', 'chinese', 3),('jack', 'math', 1), ('jack', 'english', 2), ('jack', 'chinese', 3),
('danny', 'math', 1), ('danny', 'english', 2), ('danny', 'chinese', 3)], schema=['name', 'subject', 'score'])data.groupBy('name').agg(var_pop("score")).show()
data.agg(var_pop("score")).show()#var_pop   x = 1 2 3  u=2   [(1-2)**2+(2-2)**2+(3-2)**2]/3 = 0.66666
#输出如下:
"""
+-----+------------------+
| name|    var_pop(score)|
+-----+------------------+
| jack|0.6666666666666666|
|  tom|0.6666666666666666|
|danny|0.6666666666666666|
+-----+------------------++------------------+
|    var_pop(score)|
+------------------+
|0.6666666666666666|
+------------------+
"""
#var_samp:样本方差
data.groupBy('name').agg(var_samp("score")).show()
data.agg(var_samp("score")).show()
#输出如下:
"""
+-----+---------------+
| name|var_samp(score)|
+-----+---------------+
| jack|            1.0|
|  tom|            1.0|
|danny|            1.0|
+-----+---------------++---------------+
|var_samp(score)|
+---------------+
|           0.75|
+---------------+
"""
#测试存在None值spark = SparkSession.builder.getOrCreate()data = spark.createDataFrame([('tom', 'math', 1), ('tom', 'english', 2), ('tom', 'chinese', None) ], schema=['name', 'subject', 'score'])data.groupBy('name').agg(var_pop("score")).show()  
#均值：(1+2)/2=1.5  方差((1-1.5)**2+(2-1.5)**2)/2 = 0.25
#输出如下:
"""
+-----+------------------+
| name|    var_pop(score)|
+-----+------------------+
|tom|              0.25|
+-----+------------------+
"""
10. stddev:标准差  stddev_pop:总体标准差  stddev_samp:样本标准差
#如果数据集合存在空值,则过滤掉,分母也减掉这个元素
#stddev:返回该列的标准差
"""
作用:
场景:
参数:col:列名
返回:column:返回对应结果
公式:u:(x1,x2,...,XN)平均数math.sqrt([(x1-u)**2+(x2-u)**2+...+(xN-u)**2]/(N-1))
"""
#stddev_pop:返回该列的总体标准差
"""
作用:
场景:
参数:col:列名
返回:column:返回对应结果
公式:u:(x1,x2,...,XN)平均数math.sqrt([(x1-u)**2+(x2-u)**2+...+(xN-u)**2]/N)
"""
#stddev_samp:返回该列的样本标准差
"""
作用:
场景:
参数:col:列名
返回:column:返回对应结果
公式:u:(x1,x2,...,XN)平均数math.sqrt([(x1-u)**2+(x2-u)**2+...+(xN-u)**2]/(N-1))
"""
spark = SparkSession.builder.getOrCreate()
data = spark.createDataFrame([('tom', 'math', 3), ('tom', 'english', 4), ('tom', 'chinese', 5),('jack', 'math', 3), ('jack', 'english', 4), ('jack', 'chinese', 5),
('danny', 'math', 3), ('danny', 'english', 4), ('danny', 'chinese', 5)], schema=['name', 'subject', 'score'])# 最大元素data.groupBy('name').agg(stddev("score").alias('stddev')).show()  #mean:过滤空值  avg:过滤空值data.groupBy('name').agg(stddev_pop("score")).show()data.groupBy('name').agg(stddev_samp("score")).show()
#输出如下:
"""
+-----+------+
| name|stddev|
+-----+------+
| jack|   1.0|
|  tom|   1.0|
|danny|   1.0|
+-----+------++-----+-----------------+
| name|stddev_pop(score)|
+-----+-----------------+
| jack|0.816496580927726|
|  tom|0.816496580927726|
|danny|0.816496580927726|
+-----+-----------------++-----+------------------+
| name|stddev_samp(score)|
+-----+------------------+
| jack|               1.0|
|  tom|               1.0|
|danny|               1.0|
+-----+------------------+
"""

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

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

相关文章

C语言：内存函数（memcpy memmove memset memcmp使用）

C语言：内存函数（memcpy memmove memset memcmp使用）

和黛玉学编程呀------------- 后续更新的节奏就快啦 memcpy使用和模拟实现 使用 void * memcpy ( void * destination, const void * source, size_t num ) 1.函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。 2.这个函数在遇到 \0 的时候…
阅读更多...
确保分布式系统的稳定性：深入理解接口幂等性

确保分布式系统的稳定性：深入理解接口幂等性

确保分布式系统的稳定性：深入理解接口幂等性 在分布式系统中，网络波动、系统故障或用户操作可能导致同一个请求被多次发送至服务器，如果服务器对每个重复的请求都作出新的响应，就可能导致数据的不一致或业务逻辑的错误。为了解决…
阅读更多...
常用抓包软件集合（Fiddler、Charles）

常用抓包软件集合（Fiddler、Charles）

1. Fiddler 介绍：Fiddler是一个免费的HTTP和HTTPS调试工具，支持Windows平台。它可以捕获HTTP和HTTPS流量，并提供了丰富的调试和分析功能。优点：易于安装、易于使用、支持多种扩展、可以提高开发效率。缺点：只支持Wind…
阅读更多...
龙芯3A6000_统信UOS_麒麟KYLINOS上创建密钥对加解密文件

龙芯3A6000_统信UOS_麒麟KYLINOS上创建密钥对加解密文件

原文链接：龙芯3A6000|统信UOS/麒麟KYLINOS上创建密钥对加解密文件 大家好！在当今数字化时代，数据安全变得越来越重要。为了帮助大家更好地保护自己的数据，今天我为大家带来一篇关于在统信UOS和麒麟KYLINOS操作系统上创建和使用密钥…
阅读更多...
【日常聊聊】开源软件影响力

【日常聊聊】开源软件影响力

🍎个人博客：个人主页 🏆个人专栏：JAVA ⛳️ 功不唐捐，玉汝于成 目录 前言 正文 方向一：开源软件如何推动技术创新 方向二：开源软件的商业模式 方向三：开源软件的安全风险 方…
阅读更多...
UDP和TCP的区别和联系

UDP和TCP的区别和联系

传输层：定义传输数据的协议端口号，以及流控和差错校验。 协议有：TCP、UDP等 UDP和TCP的主要区别包括以下几个方面： 1、连接性与无连接性：TCP是面向连接的传输控制协议，而UDP提供无连接的数据报服务。这意…
阅读更多...
为期 90 天的免费数据科学认证（KNIME）

为期 90 天的免费数据科学认证（KNIME）

从 2 月 1 日开始，KNIME 官方将免费提供 KNIME 认证 90 天。 无论您是刚刚迈入数据科学领域、已经掌握了一些技术，还是正在构建预测模型，都可以参加为期 90 天的 KNIME 认证挑战赛，完成尽可能多的认证并获得数据科学技能免费认证。…
阅读更多...
C#验证字符串是否纯字母：用正则表达式 vs 用Char.IsLetter方法加遍历

C#验证字符串是否纯字母：用正则表达式 vs 用Char.IsLetter方法加遍历

目录 一、使用的方法 1.使用正则表达式 2.使用Char.IsLetter方法 二、实例 1. 源码 2.生成效果 一、使用的方法 1.使用正则表达式 使用正则表达式可以验证用户输入的字符串是否为字母。匹配的正则表达式可以是：^[A-Za-z]$、^[A-Za-z]{1,}$、^[A-Za-z]*$。 …
阅读更多...
【C语言】数组的应用：扫雷游戏（包含扩展和标记功能）附完整源代码

【C语言】数组的应用：扫雷游戏（包含扩展和标记功能）附完整源代码

这个代码还是比较长的，为了增加可读性，我们还是把他的功能分装到了test.c，game.c，game.h里面。 扫雷游戏的规则相信大家来阅读本文之前已经知晓了，如果点到雷就输了，如果不是雷，点到的格子会显…
阅读更多...
Pytorch-统计学方法、分布函数、随机抽样、线性代数运算、矩阵分解

Pytorch-统计学方法、分布函数、随机抽样、线性代数运算、矩阵分解

Tensor中统计学相关的函数 torch.mean() #返回平均值 torch.sum() #返回总和 torch.prod() #计算所有元素的积 torch.max() # 返回最大值 torch.min() # 返回最小值 torch.argmax() #返回最大值排序的索引值 torch.argmin() #返回最小值排序的索引值 torch.std() #返回标准差 …
阅读更多...
BEV感知算法学习

BEV感知算法学习

BEV感知算法学习 3D目标检测系列 Mono3D(Monocular 3D Object Detection for Autonomous Driving) 流程： 通过在地平面上假设先验，在3D空间中对具有典型物理尺寸的候选边界框进行采样；然后我们将这些方框投影到图像平面上，从而避…
阅读更多...
JAVA 栈的实现

JAVA 栈的实现

洗盘子 时间限制：1.000S 空间限制：128MB 题目描述 在餐厅里，洗盘子的工作需要使用到栈这种数据结构。 假设你手里有一个盘子堆放区。现在需要模拟洗盘子的过程，每个盘子都有一个编号。 盘子堆放区操作说明： 1…
阅读更多...
在 Windows 10 上使用 Visual Studio 2022 进行 C++ 桌面开发

在 Windows 10 上使用 Visual Studio 2022 进行 C++ 桌面开发

工具下载链接：https://pan.quark.cn/s/c70b23901ccb 环境介绍 在今天的快速发展的软件开发行业中，选择合适的开发环境是非常关键的一步。对于C开发人员来说，Visual Studio 2022（VS2022）是一个强大的集成开发环境&…
阅读更多...
C#中检查空值的最佳实践

C#中检查空值的最佳实践

C#中检查空值的最佳实践 在C#编程中，处理空值是一项基础且重要的任务。正确地检查变量是否为null可以帮助我们避免NullReferenceException，这是C#最常见的运行时错误之一。本文将探讨为什么使用is关键字进行空值检查是一种优于使用的做法。 操作符&…
阅读更多...
YOLOv7改进：下采样系列 | 一种新颖的基于 Haar 小波的下采样HWD，有效涨点系列

YOLOv7改进：下采样系列 | 一种新颖的基于 Haar 小波的下采样HWD，有效涨点系列

💡💡💡本文独家改进：HWD的核心思想是应用Haar小波变换来降低特征图的空间分辨率，同时保留尽可能多的信息，与传统的下采样方法相比，有效降低信息不确定性。 💡💡💡使用方法：代替原始网络的conv，下采样过程中尽可能包括更多信息，从而提升检测精度。 收录 YO…
阅读更多...
C程序设计(第5版)谭浩强习题解答 第7章 用函数实现模块化程序设计

C程序设计(第5版)谭浩强习题解答 第7章 用函数实现模块化程序设计

C程序设计(第5版)谭浩强习题解答 第7章 用函数实现模块化程序设计 1.写两个函数,分别求两个整数的最大公约数和最小公倍数,用主函数调用这两个函数,并输出结果。两个整数由键盘输人。 //7.1.1 #include <stdio.h> int main() {int hcf(int, int);int lcd(int, int, in…
阅读更多...
聊聊DoIP吧(一）

聊聊DoIP吧(一）

DoIP是啥？ DoIP代表"Diagnostic over Internet Protocol"，即互联网诊断协议。它是一种用于在车辆诊断中进行通信的网络协议。DoIP的目标是在现代汽车中实现高效的诊断和通信。通过使用互联网协议（IP）作为通信基础，DoIP使得诊断信息能够通过网络进行传输，从而提…
阅读更多...
uniCloud -- uniIdRouter自动路由

uniCloud -- uniIdRouter自动路由

目录 自动路由 云对象响应触发needLogin 获取当前用户信息getCurrentUserInfo 实战应用 个人中心页面 pages.json配置 uni-id自动路由 uni_modules\uni-id-pages/common 登录页面store修改 自动路由 支持的HBuilderX版本 uni-appuni-app x3.5.03.99 uniIdRouter 是一…
阅读更多...
前端学习笔记 | 响应式网页+Boostrap

前端学习笔记 | 响应式网页+Boostrap

一、响应式网页 一套代码适应多端 1、媒体查询media(条件){css} max-width 小于等于max-width生效min-width 【案例】左侧隐藏 因为CSS的层叠性&#xff0c;书写顺序&#xff1a;max-width从大到小&#xff1b;min-width从小到大。 【媒体查询完整写法】 在html中link用于不同…
阅读更多...
前端小案例——导航回顶部（HTML+CSS+JS, 附源码）

前端小案例——导航回顶部（HTML+CSS+JS, 附源码）

一、前言 实现功能&#xff1a; 这个案例实现了页面滚动到一定位置时显示"回到顶部"按钮&#xff0c;并且点击按钮能够平滑滚动回页面顶部的功能。 实现逻辑&#xff1a; 页面结构&#xff1a;通过HTML标签定义了页面的基本结构。页面主要由多个div.content组成&am…
阅读更多...
最新文章

Copyright @ 2022~2023