Go语言学习Day6：数组与切片

news2024/12/24 0:26:54

名人说：莫愁千里路，自有到来风。 ——钱珝
创作者：Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊）

目录

      • 1. 数组
        • ① 什么是数组
        • ② 数组的声明
        • ③ 初始化数组的几种方式
        • ④ 遍历数组元素
        • ⑤ 数组为值类型
        • ⑥ 数组的排序
        • ⑦ 多维数组
      • 2. 切片（动态数组的抽象）
        • ① 定义切片
        • ② make来创建切片
        • ③ 切片扩容
        • ④ 遍历切片
        • ⑤ 扩容的内存分析
      • 3、小结

Go语言中的数组和切片是管理集合数据的重要方式，具有不同的特性和用途。在这篇博客中，我们将深入探讨数组和切片的相关知识点，包括它们的定义、操作方法及其内部机制。

1. 数组

① 什么是数组

数组是同一种数据类型元素的集合。在Go语言中，数组是值类型，数组的长度在声明时就已经确定，且不能改变。关于数组可以这样理解，有一个收纳盒，专门用于收集同一类书的，但是这个收纳盒容量是有限的，自从这个收纳盒生产出来大小就已经确定了，而且不能再改变，而这个收纳同一类型的盒子也就是数组。

② 数组的声明

数组声明的基本语法格式为：

var arr [n]Type

其中n表示数组的长度，Type表示数组中元素的类型。

案例：数组的定义、赋值、打印

package main

import "fmt"

/*
数组：相同类型数据的集合
*/

// 数组
func main() {
    //array 数组定义，变量
    //数组也是一种数据类型
    //数组的定义：[数组的大小size] 变量的类型
    //意思为：定义一组该类型的数组集合，大小为size，最多可以保存size个数
    var arr1 [5]int
    //[0,0,0,0,0]
    //给数组赋值，下标index从0开始
    arr1[0] = 100
    arr1[1] = 200
    arr1[2] = 300
    arr1[3] = 400
    arr1[4] = 500

    //打印数组
    fmt.Println(arr1)

    //取出数组中的某个元素
    fmt.Println(arr1[1])

    //数组中常用的方法 len()获取数组长度 cap()获取数组容量
    fmt.Println("数组的长度：", len(arr1))
    fmt.Println("数组的容量：", cap(arr1))

    //修改数组的值，index 1 代表数组中的第二个数据
    arr1[1] = 50
    fmt.Println("修改后的数组：", arr1)
    fmt.Println(arr1[1])
}

image-20240327172446685

③ 初始化数组的几种方式
  • 指定所有元素初始化
arr := [5]int{1, 2, 3, 4, 5}
  • 部分元素初始化，未初始化元素为零值
arr := [5]int{1, 2} // 其余元素初始化为0
  • 根据初始化值自动确定数组长度
arr := [...]int{1, 2, 3, 4, 5}

案例：数组初始化

package main

import "fmt"

// 数组的赋值初始化
func main() {
    //定义时初始化
    var arr1 = [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr1)

    //快速初始化 :=
    arr2 := [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr2)

    //需要注意的点
    //数据假如来自用户, 但不知道究竟有多少数据
    //... 写法
    //Go的编译器会根据数组的长度来给 ...赋值，自动推导长度
    //注意点：数组不是无限长，也是固定大小，大小取决于数组元素的个数
    var arr3 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(len(arr3))
    fmt.Println(arr3)

    //数组默认值，给其中的几个位置赋值
    //可使用{index:值}的方法
    var arr4 [10]int
    arr4 = [10]int{1: 100, 5: 500}
    fmt.Println(arr4) // [0 100 0 0 0 500 0 0 0 0]
}

image-20240329001959507

④ 遍历数组元素

遍历数组元素可以使用for循环或for range循环。

arr := [...]int{1, 2, 3, 4, 5}
for i := 0; i < len(arr); i++ {
    fmt.Println(arr[i])
}

或者

for index, value := range arr {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

上面那种方式大家可能比较熟悉，C、C++等语言中都是类似的写法，但是下面这种方式如果没学过python等语言，可能了解会少一些，因此在个人在这里解释一下：

这段代码实现了什么？

for循环遍历arr数组（或切片）。

这段代码该怎么理解？

可以这样看，每次迭代，for循环会将当前元素的索引赋值给index变量，将当前元素的值赋值给value变量，然后执行循环体内的语句。而其中的range arr就是负责生成索引和对应值的部分，比如在循环刚开始，数组中index=0，arr[index] = 1，那么所生成的index值 = 0，value值 = arr[index] = 1。

让我们逐步解析这段代码：

  1. for index, value := range arr { ... }

    • for关键字开始一个循环。
    • index, value是每次迭代时，range表达式返回的两个值。index是当前元素的索引，value是当前元素的值。
    • range arr表示对arr进行遍历。arr可以是数组或切片。range每次迭代都会返回当前元素的索引和值。
    • { ... }中的代码是循环体，会对arr中的每个元素执行一次。

  2. fmt.Printf("Index: %d, Value: %d\n", index, value)

    • 这行代码在循环体内，使用fmt.Printf函数打印当前元素的索引和值。%d是格式化字符串，用于表示整数。\n是换行符。
    • 在每次迭代中，index和value将被设置为当前遍历到的元素的索引和值，然后将它们打印出来。

举个具体的例子，如果arr是一个包含三个元素的切片[10, 20, 30]，那么输出将会是：

Index: 0, Value: 10
Index: 1, Value: 20
Index: 2, Value: 30

因此，一言以蔽之，这段代码的作用就是遍历数组（或切片）arr，并打印出每个元素的索引和值。

⑤ 数组为值类型

数组在Go语言中是值类型，当数组作为函数参数传递时，传递的是数组的副本而不是其引用。

func modifyArray(arr [5]int) {
    arr[0] = 10 // 这里修改的是数组的副本
}

案例：数组，值类型

 package main
 
 import "fmt"
 
 // 数组是值类型：所有赋值后的对象修改值不影响原来的对象
 func main() {
     //数组 [size]type
     arr1 := [4]int{1, 2, 3, 4}
     arr2 := [5]string{"yueliusu", "zilihuakai"}
     fmt.Printf("%T\n", arr1) //[4]int
     fmt.Printf("%T\n", arr2) //[5]string
 
     //数组的值传递和int等基本类型一致
     arr3 := arr1
     fmt.Println(arr1)
     fmt.Println(arr3)
 
     //修改arr3观察arr1是否会变化
     arr3[0] = 12
     fmt.Println(arr1)
     fmt.Println(arr3) // 数组是值传递，拷贝一个新的内存空间
 }

image-20240328001449100

⑥ 数组的排序

可以自定义实现，也可以使用sort包可以对数组进行排序。例如，对一个整型数组进行升序排序：

package main
import "fmt"
import "sort"

func main() {
	arr := [5]int{3, 1, 4, 5, 2}
	sort.Ints(arr[:]) // 将数组转换为切片
	fmt.Println(arr)
}

image-20240329121103889

案例：自己实现排序算法，冒泡排序

package main

import "fmt"

// 冒泡：每次筛选出一个最大或者最小的数.
/*
index   0   1   2   3   4
value   12  99  79  48  55
*/
// 冒泡排序逻辑，两两比较，大的往后移或者前移。 大
// 第一轮 ： 12 79 48 55 99 // 5
// 第二轮 ： 12 48 55 79 99 // 4
// 第三轮 ： 12 48 55 79 99 // 3 //
// 第四轮 ： 12 48 55 79 99 //
// 第五轮 ： 12 48 55 79 99

// 代码实践
/*
    // 两个数判断，如果一个数大，则交换位置，大放到后面
    if arr[x] > arr[x+1] {
       arr[x], arr[x+1] = arr[x+1],arr[x]
    }
    // 多轮判断，for， 循环次数 【数组大小】
*/
func main() {
    arr := [...]int{12, 99, 79, 48, 55, 1, 110, 111, 23, 44, 21, 312, 123, 21, 312}
    fmt.Println("初始数组：", arr)
    //冒泡排序
    //1、多少轮
    for i := 1; i < len(arr); i++ {
       //2、筛选出来最大数
       for j := 0; j < len(arr)-i; j++ {
          //降序排序，比较大小，改变升降序只需要改变符号即可
          if arr[j] < arr[j+1] {
             arr[j], arr[j+1] = arr[j+1], arr[j] //平行赋值，无需第三者临时变量进行交换
          }
       }
    }
    fmt.Println(arr)
}

image-20240329002137133

⑦ 多维数组

多维数组可以通过嵌套数组来声明（俗称套娃）。

一维，线性

二维，表格，数组套数组

三维，立体，数组套数组套数组

多维，继续嵌套

var multiArr [2][3]int
multiArr[0] = [3]int{1, 2, 3}
multiArr[1] = [3]int{4, 5, 6}

案例：多维数组

package main

import (
    "fmt"
)

func main() {

    //多维数组
    //定义一个二维数组
    arr := [3][4]int{
       {0, 1, 0, 0}, //arr[0]
       {0, 0, 1, 0}, //arr[1]
       {0, 2, 0, 0}, //arr[2]
    }

    //二维数组
    fmt.Println(arr[0])
    fmt.Println(arr[0][1])
    fmt.Println("----------")
    //遍历二维数组
    for i := 0; i < len(arr); i++ {
       for j := 0; j < len(arr); j++ {
          fmt.Println(arr[i][j])
       }
    }
    // for range
    for i, v := range arr {
       fmt.Println(i, v)
    }
}

image-20240329002342053

2. 切片（动态数组的抽象）

① 定义切片

切片是对数组的封装，它提供了一个可动态扩展的序列。切片不存储任何数据，它**只是对底层数组的引用。**那么它与数组相同吗？

显然，切片与数组是不同的，切片的长度是动态的，可以根据需要扩展或缩减。切片背后实际上是对数组的引用，切片是引用类型。

var slice []int

补充一下关于切片的基础概念：

  • 底层数组：每个切片都指向一个底层的数组，切片通过指针引用数组的一部分元素。
  • 长度（Length）：切片的长度是它所包含的元素个数。可以通过内置的len函数获取。
  • 容量（Capacity）：切片的容量是从其起始元素到底层数组末尾元素的个数。可以通过内置的cap函数获取。

案例：切片的定义

package main

import "fmt"

// 定义切片
func main() {

    arr := [4]int{1, 2, 3, 4} //数组，定长
    fmt.Println(arr)

    var s1 []int //切片，不定长，长度是可变的
    fmt.Println(s1)
    //切片空片段，初始的切片中，默认为nil
    if s1 == nil {
       fmt.Println("切片是空的")
    }

    s2 := []int{1, 2, 3, 4} //切片 不定长
    fmt.Println(s2)
    fmt.Printf("%T,%T\n", arr, s2) //[4]int,[]int
    fmt.Println(s2[1])
}

image-20240329122336156

② make来创建切片

通过make函数创建切片，可以指定切片的长度和容量。

//例如，创建一个长度为5，容量为10的切片
slice := make([]int, 5, 10)

案例：make创建切片

package main

import "fmt"

func main() {
    //make()
    //make([]Type, length, capacity) //创建一个切片，长度，容量
    s1 := make([]int, 5, 10)
    fmt.Println(s1)
    fmt.Println(len(s1), cap(s1))
    //思考：容量为10，长度为5，可以存放6个数据吗？
    s1[0] = 10
    //s1[7] = 200 //runtime error: index out of range [7] with length 5
    //切片的底层还是数组 [0 0 0 0 0] [2000]
    //直接去赋值是不行的，不要用常规的惯性想法来考虑，不加思索说出答案，思考的过程很重要。
    fmt.Println(s1)

}

image-20240329123232663

③ 切片扩容

当向切片追加元素超过其容量时，Go会自动进行扩容，一般会翻倍增加，比如说原本容量为2，你要放3个，放不下了，它会自动扩容为4，依次类推，扩容为8、16等

slice := make([]int, 0, 2)
for i := 0; i < 10; i++ {
    slice = append(slice, i)
}

案例：切片扩容，自动翻倍

package main

import "fmt"

func main() {
    //这段代码意味着创建了一个整型切片，初始长度为0，容量为5
    s1 := make([]int, 0, 5)
    fmt.Println(s1)
    //切片扩容，append()
    s1 = append(s1, 1, 2)
    fmt.Println(s1)
    //问题：容量只有5个，那能放超过5个的吗？当然，切片是会自动扩容的
    s1 = append(s1, 2, 3, 4, 5, 6, 7, 8, 9)
    fmt.Println(s1)

    s2 := []int{100, 200, 300, 400}
    // slice = append(slice, anotherSlice...)
    // ... 可变参数 ...xxx
    // [...] 根据长度变化数组的大小定义
    // anotherSlice... , slice...解构，可以直接获取到slice中的所有元素
    // s2... = {100,200,300,400}
    s1 = append(s1, s2...)
    //遍历切片
    for i := 0; i < len(s1); i++ {
       fmt.Println(s1[i])
    }

    for i := range s1 {
       fmt.Println(s1[i])
    }

}

image-20240329125405692

④ 遍历切片

切片的遍历方式和数组相同，可以使用for循环或for range循环，因为本质上切片相当于是引用了数组，数组是一种数据类型，切片引用它，扩展了它，因此遍历方式没太大差别。

slice := []int{1, 2, 3, 4, 5}
for _, value := range slice {
    fmt.Println(value)
}
⑤ 扩容的内存分析

切片的扩容会导致内存重新分配及旧数据的复制，这可能影响性能。合理规划初始容量可以减少扩容的次数，提升性能。

slice := make([]int, 0, 1024) // 提前分配足够的容量

案例：切片扩容的内存变化

package main

import "fmt"

// 切片扩容的内存分析
// 结论
// 1、每个切片引用了一个底层的数组
// 2、切片本身不存储任何数据，都是底层的数组来存储的，所以修改了切片也就是修改了这个数组中的数据
// 3、向切片中添加数据的时候，如果没有超过容量，直接添加，如果超过了容量，会自动扩容，成倍增加，copy
// - 分析程序的原理
// - 看源码
// 4、切片一旦扩容，就是重新指向一个新的底层数组

func main() {
    //1、cap每次是成倍增加的
    //2、只要容量扩容后，地址就会发生变化
    s1 := []int{1, 2, 3}
    fmt.Println(s1)
    fmt.Printf("len：%d,cap:%d\n", len(s1), cap(s1)) //len:3,cap:3
    fmt.Printf("%p\n", s1)                          //0xc000016108

    s1 = append(s1, 4, 5)
    fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:5,cap:6
    fmt.Printf("%p\n", s1)                          //0xc000010390

    s1 = append(s1, 6, 7, 8)
    fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:8,cap:12
    fmt.Printf("%p\n", s1)                          //0xc00005e060

    s1 = append(s1, 9, 10)
    fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:10,cap:12
    fmt.Printf("%p\n", s1)                          //0xc00005e060

    s1 = append(s1, 11, 12, 13, 14)
    fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:14,cap:24
    fmt.Printf("%p\n", s1)                          //0xc00010c000
}

image-20240329125625358

案例2：copy方法

package main

import "fmt"

// copy方法
func main() {
    numbers := []int{1, 2, 3}
    fmt.Printf("len=%d,cap=%d,slice=%v\n", len(numbers), cap(numbers), numbers)

    //方法一：直接使用make创建切片扩容
    numbers2 := make([]int, len(numbers), cap(numbers)*2)
    //将原来的底层数据的值拷贝到新的数组中
    //func copy(dst,src []Type)int
    copy(numbers2, numbers)
    fmt.Printf("len=%d,cap=%d,slice=%v\n", len(numbers2), cap(numbers2), numbers2)
}

image-20240329125643799

3、小结

数组

  • 一组数
  • 数组是值传递的
  • 创建数组 [size]int
  • 数组的大小事不可变的
  • 二维数组，数组套数组
  • 冒泡排序

切片

  • 切片本事是不存在数据的
  • 底层是指向了一个数组
  • 如果我们存放的数据大于切片的容量，在底层就会扩容 copy > 1024 1.25倍

很感谢你能看到这里，如有相关疑问，还请下方评论留言。
Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊）
希望本篇内容能对大家有所帮助，如果大家喜欢的话，请动动手点个赞和关注吧，非常感谢你们的支持！

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

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

相关文章

深入理解Vue 3.0中Async/Await 语法

深入理解Vue 3.0中Async/Await 语法

引言 在 JavaScript 中&#xff0c;异步操作一直是一个挑战&#xff0c;因为它们通常涉及回调函数的嵌套和复杂的 Promise 链式调用。为了解决这些问题&#xff0c;ES8 引入了 Async/Await 语法&#xff0c;它提供了一种更简洁、易读的方式来处理异步操作。 Async/Await 主要…
阅读更多...
使用mysql官网软件包安装mysql

使用mysql官网软件包安装mysql

确定你的操作系统&#xff0c;我的是Centos myqsl 所有安装包的地址&#xff1a;https://repo.mysql.com/yum/ 如果你是使用rpm安装你可以到对应的版本里面找到对应的包。 mysql 发行包的地址&#xff1a;http://repo.mysql.com/ 在这里你可以找到对应的发布包安装。 这里使用y…
阅读更多...
【3DsMax+Pt】练习案例

【3DsMax+Pt】练习案例

目录 一、在3DsMax中展UV 二、在Substance 3D Painter中绘制贴图 一、在3DsMax中展UV 1. 首先创建如下模型 2. 选中如下三条边线作为接缝 重置剥 发现如下部分还没有展开 再选一条边作为接缝 再次拨开 拨开后的UV如下 二、在Substance 3D Painter中绘制贴图 1. 新建项目&am…
阅读更多...
MIPI RFFE接口

MIPI RFFE接口

1. 概况 MIPI RFFE是一种专门针对当前及未来无线系统在射频(RF)前端控制界面规范。随着手机射频系统日趋复杂&#xff0c;业界需要一个单一控制界面解决方案。MIPI联盟的RF前端控制界面(RFFE)规范通过提供一个可连接到收发器或无线电的总线界面解决了这一难题&#xff0c;可用于…
阅读更多...
【机器学习】数据探索(Data Exploration)---数据质量和数据特征分析

【机器学习】数据探索(Data Exploration)---数据质量和数据特征分析

一、引言 在机器学习项目中&#xff0c;数据探索是至关重要的一步。它不仅是模型构建的基础&#xff0c;还是确保模型性能稳定、预测准确的关键。数据探索的过程中&#xff0c;数据质量和数据特征分析占据了核心地位。数据质量直接关系到模型能否从数据中提取有效信息&#xff…
阅读更多...
分布式部署LNMP+WordPress

分布式部署LNMP+WordPress

需要四台虚拟机&#xff0c;实际上&#xff0c;我们只需要操作三台 一个数据库&#xff0c;一个nginx&#xff0c;一个php&#xff0c;还需要准备一个软件包wordpress-4.7.3-zh_C 首先配置nginx的服务环境 [rootnginx ~]# vi /usr/local/nginx/conf/nginx.conf 修改文件中的loc…
阅读更多...
1.8 python 模块 time、random、string、hashlib、os、re、json

1.8 python 模块 time、random、string、hashlib、os、re、json

ython之模块 一、模块的介绍 &#xff08;1&#xff09;python模块&#xff0c;是一个python文件&#xff0c;以一个.py文件&#xff0c;包含了python对象定义和pyhton语句 &#xff08;2&#xff09;python对象定义和python语句 &#xff08;3&#xff09;模块让你能够有逻辑地…
阅读更多...
从零开始的软件开发实战：互联网医院APP搭建详解

从零开始的软件开发实战：互联网医院APP搭建详解

今天&#xff0c;笔者将以“从零开始的软件开发实战&#xff1a;互联网医院APP搭建详解”为主题&#xff0c;深入探讨互联网医院APP的开发过程和关键技术。 第一步&#xff1a;需求分析和规划 互联网医院APP的主要功能包括在线挂号、医生预约、医疗咨询、健康档案管理等。我们…
阅读更多...
Elasticsearch 向量搜索

Elasticsearch 向量搜索

目标记录 ["你好&#xff0c;我的爱人","你好&#xff0c;我的爱妻","你好&#xff0c;我的病人","世界真美丽"] 搜索词 爱人 预期返回 ["你好&#xff0c;我的爱人","你好&#xff0c;我的爱妻"] 示例代码…
阅读更多...
企业微信知识库：从了解到搭建的全流程

企业微信知识库：从了解到搭建的全流程

你是否也有这样的疑惑&#xff1a;为什么现在的企业都爱创建企业微信知识库&#xff1f;企业微信知识库到底有什么用&#xff1f;如果想要使用企业微信知识库企业应该如何创建&#xff1f;这就是我今天要探讨的问题&#xff0c;感兴趣的话一起往下看吧&#xff01; | 为什么企业…
阅读更多...
踏入网页抓取的旅程：使用 grequests 构建 Go 视频下载器

踏入网页抓取的旅程：使用 grequests 构建 Go 视频下载器

引言 在当今数字化的世界中&#xff0c;网页抓取技术变得越来越重要。无论是获取数据、分析信息&#xff0c;还是构建自定义应用程序&#xff0c;我们都需要从互联网上抓取数据。本文将介绍如何使用 Go 编程语言和 grequests 库来构建一个简单的 Bilibili 视频下载器&#xff…
阅读更多...
小米汽车正式发布：开启智能电动新篇章

小米汽车正式发布：开启智能电动新篇章

随着科技的不断进步&#xff0c;汽车产业正经历着前所未有的变革。智能电动汽车作为这一变革的重要方向&#xff0c;正吸引着越来越多的目光。在这个充满机遇和挑战的时代&#xff0c;小米汽车凭借其卓越的技术实力和深厚的市场底蕴&#xff0c;终于迈出了坚实的一步。今天&…
阅读更多...
FSV13罗德与施瓦茨FSV13频谱分析仪

FSV13罗德与施瓦茨FSV13频谱分析仪

181/2461/8938产品概述&#xff1a; 罗德与施瓦茨 FSV13 是一款速度极快且多功能的信号和频谱分析仪&#xff0c;适用于从事射频系统开发、生产、安装和维修工作的注重性能、注重成本的用户。 在开发应用中&#xff0c;罗德与施瓦茨 FSV13 凭借其出色的射频特性、同类产品中无…
阅读更多...
论文笔记：分层问题-图像共注意力问答

论文笔记：分层问题-图像共注意力问答

整理了2017 Hierarchical Question-Image Co-Attention for Visual Question Answering&#xff09;论文的阅读笔记 背景模型问题定义模型结构平行共注意力交替共注意力 实验可视化 背景 视觉问答(VQA)的注意力模型在此之前已经有了很多工作&#xff0c;这种模型生成了突出显示…
阅读更多...
EDA 全加器设计及例化语句应用

EDA 全加器设计及例化语句应用

文章目录 前言一、全加器是什么&#xff1f;二、使用步骤1.半加器2.全加器1.新建一个全加器工程2.添加半加器的.v文件到全加器工程中3.新建全加器.v文件&#xff0c;写程序&#xff0c;调用半加器.v文件 完成例化 三、仿真效果总结 前言 提示&#xff1a;这里可以添加本文要记…
阅读更多...
【Linux】体验一款开源的Linux服务器运维管理工具

【Linux】体验一款开源的Linux服务器运维管理工具

今天为大家介绍一款开源的 Linux 服务器运维管理工具 - 1panel。 一、安装 根据官方那个提供的在线文档&#xff0c;这款工具的安装需要执行在线安装&#xff0c; # Redhat / CentOScurl -sSL https://resource.fit2cloud.com/1panel/package/quick_start.sh -o quick_start…
阅读更多...
腾讯云邮件推送功能有哪些？如何有效使用？

腾讯云邮件推送功能有哪些？如何有效使用？

腾讯云邮件推送如何设置&#xff1f;怎么用邮件推送做高效营销&#xff1f; 腾讯云作为业界领先的云服务提供商&#xff0c;其邮件推送功能在便捷性、稳定性和安全性上都有着出色的表现。那么&#xff0c;腾讯云邮件推送功能究竟有哪些呢&#xff1f;让AokSend来探个究竟。 腾…
阅读更多...
基于Python的电商特产数据可视化分析与推荐系统

基于Python的电商特产数据可视化分析与推荐系统

温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长 QQ 名片 :) 1. 项目简介 利用网络爬虫技术从某东采集某城市的特产价格、销量、评论等数据&#xff0c;经过数据清洗后存入数据库&#xff0c;并实现特产销售、市场占有率、价格区间等多维度的可视化统计分析&#xff0c;并…
阅读更多...
愚人节海外网红营销：如何避免“愚人”变“愚己”？

愚人节海外网红营销：如何避免“愚人”变“愚己”？

2024年愚人节即将到来&#xff0c;这个一年一度的日子既是欢乐的时刻&#xff0c;也是一个对品牌来说充满挑战的时刻。在这一天&#xff0c;人们习惯性地开展各种恶作剧和愚人行为&#xff0c;而对于企业和品牌来说&#xff0c;通过海外网红营销参与其中&#xff0c;既是一种与…
阅读更多...
C＃OpenCvSharp YOLO v3 Demo

C＃OpenCvSharp YOLO v3 Demo

目录 效果 项目 代码 下载 效果 项目 代码 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using OpenCvSharp; using S…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023