Go学习第八章——面向“对象”编程（结构体与方法）

Go面向“对象”编程（结构体与方法）

      • 1 结构体
        • 1.1 快速入门
        • 1.2 内存解析
        • 1.3 创建结构体四种方法
        • 1.4 注意事项和使用细节
      • 2 方法
        • 2.1 方法的声明和调用
        • 2.2 快速入门案例
        • 2.3 调用机制和传参原理
        • 2.4 注意事项和细节
        • 2.5 方法和函数区别
      • 3 工厂模式

Golang语言面向对象编程说明：

  1. Golang也支持面向对象编程(OOP)，但是和传统的面向对象编程有区别，并不是纯粹的面向对象语言。所以我们说Golang支持面向对象编程特性是比较准确的。
  2. Golang没有类(class)，Go语言的结构体(struct)和其它编程语言的类(class)有同等的地位，你可以理解Gelang是基于struct来实现OOP特性的。
  3. Golang面向对象编程非常简洁，去掉了传统OOP语言的方法重载、构造函数和析构函数、隐藏的this指针等等。
  4. Golang仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其它OOP语言不一样，比如继承:Golang没有extends 关键字，继承是通过匿名字段来实现。
  5. Golang面向对象（OOP）很优雅，OOP本身就是语言类型系统(type system)的一部分，通过接口(interface)关联，耦合性低，也非常灵活。后面同学们会充分体会到这个特点。也就是说在Golang中面向接口编程是非常重要的特性。

1 结构体

1.1 快速入门

假设定义结构体是老师，属性：名字，年龄，学校

type Teacher struct {
	//变量名字大写外界可以访问这个属性
	Name   string
	Age    int
	School string
}

下面我们尝试赋值，并打印出来：

type Teacher struct {
	//变量名字大写外界可以访问这个属性
	Name   string
	Age    int
	School string
}

func main() {
	var tea1 Teacher
	tea1.Name = "张三"
	tea1.Age = 28
	tea1.School = "深圳大学"
	fmt.Println("tea1=", tea1)

	fmt.Println("老师的信息如下：")
	fmt.Println("name=", tea1.Name)
	fmt.Println("age=", tea1.Age)
	fmt.Println("school=", tea1.School)
}

输出结果：

tea1= {张三 28 深圳大学}
老师的信息如下：
name= 张三      
age= 28         
school= 深圳大学

通过上面的案例和讲解可以看出：

  1. 结构体是自定义的数据类型，代表一类事务。
  2. 结构体变量（实例）是具体的，实际的，代表一个具体变量。
1.2 内存解析

在Go语言中，结构体的存储是在堆上。

当我们创建一个结构体实例时，它的内存将被分配在堆上。这意味着结构体的生命周期可以超出创建它的函数的生命周期。

例如，当我们使用new关键字或make函数创建一个结构体实例时，它将被分配在堆上。

type Person struct {
    Name string
    Age  int
}

func main() {
    // 使用 new 关键字创建结构体实例
    p := new(Person)
    p.Name = "Alice"
    p.Age = 25

    // 使用 make 函数创建结构体实例（只适用于为某些类型分配内存，如 map、slice 和 channel）
    m := make(map[string]int)
    m["key"] = 42
    
    // 结构体实例被分配在堆上，可以在其他函数中继续使用
    anotherFunc(p)
    yetAnotherFunc(m)
}

这是因为在Go语言中，所有的变量都是通过传值而不是通过引用传递。在堆上分配结构体实例可以确保结构体数据的持久性和可用性。

image-20231025144249457

Go语言中结构体的内存布局

Go语言中的结构体是一组值的集合，这些值被存储在内存中的一段连续的区域。结构体的内存布局取决于结构体中的成员变量顺序和类型，以及对齐方式。

结构体的对齐方式

Go语言中使用的是一种称为Packing的方式进行对齐。这种方式默认对齐到最多8字节的倍数，即8字节对齐。可以通过在结构体成员变量的后面添加逗号和数字的形式手动调节对齐方式。

type Person struct {
	Name   string
	Age    int
	Height float64
}

func main() {
	var p Person

	// 获取结构体的大小
	size := unsafe.Sizeof(p)
	fmt.Printf("结构体大小：%d 字节\n", size)

	// 获取结构体字段的偏移量
	nameOffset := unsafe.Offsetof(p.Name)
	ageOffset := unsafe.Offsetof(p.Age)
	heightOffset := unsafe.Offsetof(p.Height)
	fmt.Printf("Name 字段的偏移量：%d 字节\n", nameOffset)
	fmt.Printf("Age 字段的偏移量：%d 字节\n", ageOffset)
	fmt.Printf("Height 字段的偏移量：%d 字节\n", heightOffset)

	// 结构体的对齐方式
	packed := unsafe.Alignof(p)
	fmt.Printf("结构体的对齐方式：%d 字节\n", packed)
｝

输出结果：

结构体大小：20 字节
Name 字段的偏移量：0 字节   
Age 字段的偏移量：8 字节    
Height 字段的偏移量：12 字节
结构体的对齐方式：4 字节

在这个示例中，我们定义了一个Person结构体，它包括名字、年龄和身高三个字段。我们通过unsafe包中的函数来获取结构体的大小、字段的偏移量以及对齐方式。结构体的大小为20字节，字段的偏移量分别为0字节、8字节和12字节，结构体的对齐方式为4字节。

1.3 创建结构体四种方法

基本介绍

  1. 从概念或叫法上：结构体字段 = 属性 = field
  2. 字段是结构体的一个组成部分，一般是基本数据类型、数组、也可以是引用数据类型。
  3. 指针，slice和map的零值都是nil，即还没有分配空间。

方式一：直接声明

案例：var person Person

方式二：{}

案例：var person Person = Person{“Tom”, 18} => person := Person{“Tom”, 18}

方式三：&

案例：var person *Person = new (Person)

type Person struct {
	Name string
	Age  int
}

func main() {
	var p *Person = new(Person)
	// (*p).Name = "smith" 标准写法
	// go设计者，为了程序使用方便，底层对下面这个做了优化，实现了这种简单的写法
	// 会给 p 加上 取值运算 =》 (*p).Name = "smith" 
	p.Name = "smith" 
	p.Age = 18
	fmt.Println(p)
	fmt.Println(*p)
}

输出结果：

&{smith 18}
{smith 18}

方式四：{}

案例：var person *Person = &Person{}

type Person struct {
	Name string
	Age  int
}

func main() {
	var p *Person = &Person{}
	// 标准方式：(*person).Name = "scott"
	p.Name = "scott"
	p.Age = 18
	fmt.Println(p)
}

输出结果：&{scott 18}

1.4 注意事项和使用细节
  1. 结构体的所有字段在内存中是连续的，指针本身的地址是连续的，但是指向的地址不一定是连续的。

image-20231025153910544

//结构体
type Point struct {
    x int
    y int
}

//结构体
type Rect struct {
    leftUp, rightDown Point
}

//结构体
type Rect2 struct {
    leftUp, rightDown *Point
}

func main() {

    r1 := Rect{Point{1,2}, Point{3,4}} 

    //r1有四个int, 在内存中是连续分布
    //打印地址
    fmt.Printf("r1.leftUp.x 地址=%p r1.leftUp.y 地址=%p r1.rightDown.x 地址=%p r1.rightDown.y 地址=%p \n", 
    &r1.leftUp.x, &r1.leftUp.y, &r1.rightDown.x, &r1.rightDown.y)

    //r2有两个 *Point类型，这个两个*Point类型的本身地址也是连续的，
    //但是他们指向的地址不一定是连续

    r2 := Rect2{&Point{10,20}, &Point{30,40}} 

    //打印地址
    fmt.Printf("r2.leftUp 本身地址=%p r2.rightDown 本身地址=%p \n", 
       &r2.leftUp, &r2.rightDown)

    //他们指向的地址不一定是连续...， 这个要看系统在运行时是如何分配
    fmt.Printf("r2.leftUp 指向地址=%p r2.rightDown 指向地址=%p \n", 
       r2.leftUp, r2.rightDown)
}

输出结果：

r1.leftUp.x 地址=0x9496080 r1.leftUp.y 地址=0x9496084 r1.rightDown.x 地址=0x9496088 r1.rightDown.y 地址=0x949608c
r2.leftUp 本身地址=0x948a038 r2.rightDown 本身地址=0x948a03c
r2.leftUp 指向地址=0x9496068 r2.rightDown 指向地址=0x94960a0

  1. 结构体之间可以转换，但是有要求，就是结构体的字段要完全一样（包括：名字、类型，个数）

    type A struct {
	Num int
}

type B struct {
	Num int
}

func main() {
	var a A
	var b B
	a = A(b)
	fmt.Println(a, b)
}

  2. 结构体进行type重新定义（相当于取别名），Golang认为是新的数据类型，但是相互间可以强转。

type Student struct {
	Name string
	Age  int
}

type Stu Student

func main() {
	var stu1 Student
	var stu2 Stu
	// stu2 = stu1 // 错误，系统认为这是两个不一样的类型
	stu2 = Stu(stu1)
	fmt.Println(stu1, stu2)
}

  1. struct的每个字段上，可以写上一个标签tag，该tag可以通过反射机制获取，常见的使用场景就是序列化和反序列化。

    type Student struct {
	Name string `json:"name"` // 这里就是结构体的标签tag
	Age  int    `json:"age"`
}

func main() {
	// 1.创建一个student变量
	student := Student{"张三", 18}
	// 2.将monster变量序列化为json格式字符串
	jsonStr, err := json.Marshal(student) // 这里json.Marshal底层用到了反射
	if err != nil {
		fmt.Println("jsonStr报错")
	}
	fmt.Println("jsonStr:", jsonStr)
	fmt.Println("string(jsonStr):", string(jsonStr))
}

    如果这里不加上标签，生成的json格式，就变成：string(jsonStr): {"Name":"张三","Age":18}

    会发现，这里的Name的首字母是大写，这又是不可避免，因为小写就调用不了

    所以这里通过标签，设置一个别名，底层用了反射解决这个问题~~~

    输出结果：string(jsonStr): {"name":"张三","age":18}

2 方法

在某些情况下，我们需要声明（定义）方法。比如Person结构体：除了有一些字段外(年龄，姓名…)，Person结构体还有一些行为。比如：可以说好，跑步，学习等，还可以做算术题。这时就要用方法才能完成

Golang中的方法是作用在指定的数据类型上的（即：和指定的数据类型绑定），因此自定义类型，都可以有方法，而不仅仅只是struct。

2.1 方法的声明和调用
type A struct {
    Num int
}

func (a A) test() {
    fmt.Println(a.Num)
}

对上面的语法说明：

  1. func (a A) test() {} 表示A结构体有一方法，方法名为 test
  2. (a A) 体现test方法是和A类型绑定的
type Person struct {
	Name string
}

func (p Person) test() {
	p.Name = "Tom"
	fmt.Println("test():", p.Name)
}

func main() {
	person := Person{Name: "张三"}
	person.test() // 调用方法
	fmt.Println("main p.Name=", person.Name)
}

输出结果：

test(): Tom
main p.Name= 张三

对上面的总结：

  1. test方法和Person类型绑定

  2. test方法只能通过Person类型的遍历来调用，而不能直接调用，也不嫩更实用其他类型变量来调用。

  3. func (p Person) test() {} 这个p是它的副本，进行的是值传递，与函数很像。

2.2 快速入门案例

  1. 给Person结构体添加speak 方法，输出 xxx是一个好人

    type Person struct{
	Name string
}

//给Person结构体添加speak 方法,输出  xxx是一个好人
func (p Person) speak() {
	fmt.Println(p.Name, "是一个goodman~")
}

  2. 给Person结构体添加jisuan 方法,可以计算从 1+…+1000的结果,

    type Person struct {
	Name string
}

func (p Person) jisuan() {
	res := 0
	for i := 1; i <= 1000; i++ {
		res += i
	}
	fmt.Println(p.Name, "计算的结果是=", res)
}

func main() {
	p := Person{Name: "张三"}
	p.jisuan() // 输出：张三 计算的结果是= 500500
}

  3. 给Person结构体jisuan2 方法,该方法可以接收一个参数n，计算从 1+…+n 的结果

    type Person struct {
	Name string
}

// 给Person结构体jisuan2 方法,该方法可以接收一个参数n，计算从 1+..+n 的结果
func (p Person) jisuan2(n int) {
	res := 0
	for i := 1; i <= n; i++ {
		res += i
	}
	fmt.Println(p.Name, "计算的结果是=", res)
}

func main() {
	p := Person{Name: "张三"}
	p.jisuan2(10) // 输出：张三 计算的结果是= 55
}

  4. 给Person结构体添加getSum方法,可以计算两个数的和，并返回结果

    type Person struct {
	Name string
}

// 给Person结构体添加getSum方法,可以计算两个数的和，并返回结果
func (p Person) getSum(n1 int, n2 int) int {
	return n1 + n2
}

func main() {
	p := Person{Name: "张三"}
	sum := p.getSum(1, 1)
	fmt.Printf("%v sum=%v", p.Name, sum) //输出：张三 sum=2
}
2.3 调用机制和传参原理

说明：方法的调用和传参机制和函数基本一样，不一样的地方是方法调用时，会将调用方法的变量，当作实参也传递给方法。下面举例说明：

案例：

image-20231025165316278

type Person struct {
	Name string
}

// 给Person结构体添加getSum方法,可以计算两个数的和，并返回结果
func (p Person) getSum(n1 int, n2 int) int {
	return n1 + n2
}

func main() {
	p := Person{Name: "张三"}
	n1 := 10
	n2 := 20
	res := p.getSum(n1, n2)
	fmt.Println("res=", res)
}
  1. 在通过一个变量去调用方法时，其调用机制和函数一样
  2. 不一样的地方是，变量调用方法时，该变量本身也会作为一个参数传递到方法（如果变量是值类型，则进行值拷贝，如果是引用类型，则进行地质拷贝）
2.4 注意事项和细节
  1. 结构体类型是值类型，在方法调用中，遵守值类型的传递机制，是值拷贝传递方式
  2. 如果程序员希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理
  3. Golang中的方法作用在指定的数据类型上的(即: 和指定的数据类型绑定),因此自定义类型，都可以有方法，而不仅仅是struct，比如int ,float32等都可以有方法
  4. 方法的访问范围控制的规则，和函数一样。方法名首字母小写，只能在本包4访问，方法首字母大写，可以在本包和其它包访问。
  5. 如果一个类型实现了String这个方法，那么fmt.Println默认会调用这个变量的String()进行输出

上面这些注意事项都比较简单，就代码展示一下最后一条：

type Student struct {
	Name string
	Age  int
}

// 给*Student实现方法String()
func (stu *Student) String() string {
	str := fmt.Sprintf("Name=[%v] Age=[%v]", stu.Name, stu.Age)
	return str
}

func main() {
	//定义一个Student变量
	stu := Student{
		Name: "tom",
		Age:  20,
	}
	//如果你实现了 *Student 类型的 String方法，就会自动调用
	fmt.Println(stu)
	fmt.Println(&stu)
}

输出结果：

{tom 20}
Name=[tom] Age=[20]
2.5 方法和函数区别
  1. 调用方式不一样
  • 函数的调用方式：函数名（实参列表）
  • 方法的调用方式：变量.方法名（实参列表）
  1. 数据传递的限制不一样
  • 对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然。
  • 对于方法（如struct的方法），接收者为值类型时，可以直接用指针类型的遍历调用方法，反过来同样也可以。

这一点很容易迷糊，下面用段代码解释一下：

type Person struct {
    Name string
}

//函数
//对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然

func test01(p Person) {
    fmt.Println(p.Name)
}

func test02(p *Person) {
    fmt.Println(p.Name)
}

//对于方法（如struct的方法），
//接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以

func (p Person) test03() {
    p.Name = "jack"
    fmt.Println("test03() =", p.Name) // jack
}

func (p *Person) test04() {
    p.Name = "mary"
    fmt.Println("test03() =", p.Name) // mary
}

func main() {

    p := Person{"tom"}
    test01(p)
    test02(&p)

    p.test03()
    fmt.Println("main() p.name=", p.Name) // tom

    (&p).test03() // 从形式上是传入地址，但是本质仍然是值拷贝

    fmt.Println("main() p.name=", p.Name) // tom

    (&p).test04()
    fmt.Println("main() p.name=", p.Name) // mary
    p.test04()   // 等价 (&p).test04 , 从形式上是传入值类型，但是本质仍然是地址拷贝
}

输出结果：

tom
tom
test03() = jack
main() p.name= tom
test03() = jack
main() p.name= tom
test03() = mary
main() p.name= mary
test03() = mary

从代码会发现，仅管传递的是一个地址，但是编译器进行了内部优化，实际上还是值传递，只是支持这种写法，但并不是进行一个地址值的修改。

3 工厂模式

说明：Golang的结构体没有构造函数，通常可以使用工厂模式来解决这个问题

相当于，这个工厂模式，就是以前构造函数的功能。

看个需求：

一个结构体的声明如下:

package model

type Student struct {
	Name string
}

因为这里的 Student 的首字母S是大写的，如果我们想在其他包串接Student的实例（比如：main包），引入model包后，就可以直接创建Student结构体的变量（实例）。

但是问题来了，如果搜字母是小写的，比如是： type student struct {…}就不行了，咋办？-》工厂模式来解决，

Model包

package model

type student struct {
	name  string
	score float64
}

// 因为student结构体首字母是小写，因此是只能在model使用
// 通过工厂模式来解决
func NewStudent(n string, s float64) *student {
	return &student{
		name:  n,
		score: s,
	}
}

// 如果score字段首字母小写，则，在其他包不可以直接方法，我们可以提供一个方法
func (s *student) GetScore() float64 {
	return s.score
}

// 如果score字段首字母小写，则，在其他包不可以直接方法，我们可以提供一个方法
func (n *student) GetName() string {
	return n.name
}

main包

import (
	"GoStudy_Day1/model"
	"fmt"
)

func main() {
	// 定student结构体是首字母小写，我们可以通过工厂模式来解决
	stu := model.NewStudent("Tom", 88.8)
	fmt.Println(stu)
	fmt.Println(*stu)
	// fmt.Println("name=", stu.name) // 报错，因为是私密的
	fmt.Println("name=", stu.GetName())
	fmt.Println("score=", stu.GetScore())
}

输出结果：

&{Tom 88.8}
{Tom 88.8}
name= Tom
score= 88.8

其实，这就看出来，就是Java的GetSet，绕了一圈，又回来啦~~~！！！！！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

服装服饰小程序商城的作用是什么

服装服饰小程序商城的作用是什么

随着数字化转型节奏加快&#xff0c;各个行业都在加紧线上平台渠道的建设&#xff0c;而对于服装业来讲&#xff0c;在线商城无疑是**的选择&#xff0c;一方面可以去除平台的限制&#xff0c;摆脱佣金烦恼&#xff0c;还可搭建自有会员体系、私域流量池&#xff0c;持续转化变…
阅读更多...
使用ruoyi框架遇到的问题修改记录

使用ruoyi框架遇到的问题修改记录

使用ruoyi框架遇到的问题修改记录 文章目录 使用ruoyi框架遇到的问题修改记录上传后文件名改变上传时设置单多文件及其他选项附件显示文件名&#xff0c;点击下载附件直接显示图片表格固定列查询数据库作为下拉选项值字典使用加入json递归注解&#xff0c;防止无限递归内存溢出…
阅读更多...
从零开始学习wpsjs

从零开始学习wpsjs

1.这是一个简单的wpsjs学习文档&#xff0c;我是边学习wpsjs边记录学习的&#xff0c;希望对您的学习有所帮助 开发事项&#xff1a; 全局安装wpsjs:npm install -g wpsjsWpsjs create HelloWps 安装wps npm install -g wpsjs 新建一个wps加载项 输入命令wpsjs create HelloW…
阅读更多...
塔式服务器介绍

塔式服务器介绍

大家都知道服务器分为机架式服务器、刀片式服务器、塔式服务器三类&#xff0c;今天小编就分别讲一讲这三种服务器&#xff0c;第三篇先来讲一讲塔式服务器的介绍。 塔式服务器定义&#xff1a;塔式服务器的外观和普通电脑差不多&#xff0c;直立放置。机箱比较大&#xff0c;服…
阅读更多...
药房商城小程序便捷购药体验，找药买药一键操作

药房商城小程序便捷购药体验，找药买药一键操作

在我们的生活中&#xff0c;偶尔会遇到身体不适或需要常见药品的情况。然而&#xff0c;传统的购药方式往往会浪费大量的时间和精力。幸运的是&#xff0c;现在有了药房商城小程序&#xff0c;仅需一键操作&#xff0c;您就能享受到便捷、高效的购药体验。 药房商城小程序是用于…
阅读更多...
聊聊分布式架构10——Zookeeper入门详解

聊聊分布式架构10——Zookeeper入门详解

目录 01ZooKeeper的ZAB协议 ZAB协议概念 ZAB协议基本模式 消息广播 崩溃恢复 选举出新的Leader服务器 数据同步 02Zookeeper的核心 ZooKeeper 的核心特点 ZooKeeper 的核心组件 选举算法概述 服务器启动时的Leader选举 服务器运行期间的Leader选举 03ZooKeeper的…
阅读更多...
Netty核心源码剖析

Netty核心源码剖析

Netty 线程模型 Netty高并发高性能架构设计精髓 主从Reactor线程模型NIO多路复用非阻塞无锁串行化设计思想支持高性能序列化协议零拷贝(直接内存的使用)ByteBuf内存池设计灵活的TCP参数配置能力并发优化 无锁串行化设计思想 在大多数场景下&#xff0c;并行多线程处理可以提…
阅读更多...
安卓使用android studio跨进程通信之AIDL

安卓使用android studio跨进程通信之AIDL

我写这篇文章不想从最基础的介绍开始,我直接上步骤吧. 1.创建服务端 1.1:创建服务端项目:我的as版本比较高,页面就是这样的 1.2:创建AIDL文件,右键项目,选中aidl aidl名字可以自定义也可以默认 basicTypes是自带的,可以删掉,也可以不删,然后把你自己所需的接口写上去 1.3:创建…
阅读更多...
CSS 两栏布局

CSS 两栏布局

目录 CSS两栏布局&#xff08;左列定宽&#xff0c;右列自适应宽&#xff09; 方法一&#xff1a;浮动margin 方法二&#xff1a;定位margin 方法三&#xff1a;浮动BFC 方法四&#xff1a;Flex布局 方法五&#xff1a;able布局 CSS两栏布局&#xff08;左列不定宽&#…
阅读更多...
uniapp 自定义导航栏

uniapp 自定义导航栏

自定义导航栏 修改 pages.json 在 pages.json 中将 navigateionStyle 设为 custom 新建 systemInfo.js systemInfo.js 用来获取当前设备的机型系统信息&#xff0c;放在 common 目录下 /*** 此 js 文件管理关于当前设备的机型系统信息*/ const systemInfo function() {/***…
阅读更多...
信息检索与数据挖掘 | 【实验】排名检索模型

信息检索与数据挖掘 | 【实验】排名检索模型

文章目录 &#x1f4da;实验内容&#x1f4da;相关概念&#x1f4da;实验步骤&#x1f407;分词预处理&#x1f407;构建倒排索引表&#x1f407;计算query和各个文档的相似度&#x1f407;queries预处理及检索函数&#x1f525;对输入的文本进行词法分析和标准化处理&#x1f…
阅读更多...
从0开始在Vscode中搭建Vue2/3项目详细步骤

从0开始在Vscode中搭建Vue2/3项目详细步骤

1.安装node.js:Node.js下载安装及环境配置教程【超详细】_nodejs下载_WHF__的博客-CSDN博客 node.js自带npm&#xff0c;无需单独安装。 验证&#xff1a; node -v npm -v 2.先简单创建一个空文件夹&#xff0c;vscode进入该文件夹&#xff0c;并打开终端。 3.安装cnpm&…
阅读更多...
【Gensim概念】03/3 NLP玩转 word2vec

【Gensim概念】03/3 NLP玩转 word2vec

第三部分 对象函数 八 word2vec对象函数 该对象本质上包含单词和嵌入之间的映射。训练后&#xff0c;可以直接使用它以各种方式查询这些嵌入。有关示例&#xff0c;请参阅模块级别文档字符串。 类型 KeyedVectors 1&#xff09; add_lifecycle_event(event_name, log_level2…
阅读更多...
OpenCV视频车流量识别详解与实践

OpenCV视频车流量识别详解与实践

视频车流量识别基本思想是使用背景消去算法将运动物体从图片中提取出来&#xff0c;消除噪声识别运动物体轮廓&#xff0c;最后&#xff0c;在固定区域统计筛选出来符合条件的轮廓。 基于统计背景模型的视频运动目标检测技术&#xff1a; 背景获取&#xff1a;需要在场景存在…
阅读更多...
React 框架

React 框架

1、React 框架简介 1.1、介绍 CS 与 BS结合&#xff1a;像 React&#xff0c;Vue 此类框架&#xff0c;转移了部分服务器的功能到客户端。将CS 和 BS 加以结合。客户端只用请求一次服务器&#xff0c;服务器就将所有js代码返回给客户端&#xff0c;所有交互类操作都不再依赖服…
阅读更多...
禁止拷贝文件到U盘的解决办法

禁止拷贝文件到U盘的解决办法

禁止拷贝文件到U盘的解决办法 安企神U盘管理系统下载使用 说到这问题&#xff0c;大多情况下是企业的需求&#xff0c;很多公司电脑中都保存着极为重要的数据&#xff0c;这些数据往往是不能传播的&#xff0c;所以此时就需要禁止拷贝文件到U盘来防止公司数据被泄密。 禁止拷…
阅读更多...
python造测试数据存到excel

python造测试数据存到excel

代码&#xff1a; from ExcelHandler import ExcelHandler from faker import Faker # 导入faker库的Faker方法 # ↓默认为en_US&#xff0c;只有使用了相关语言才能生成相对应的随机数据 fkFaker(locale"zh_CN")def create_date():m int(input(请输入要造的数据条…
阅读更多...
自动驾驶的商业应用和市场前景

自动驾驶的商业应用和市场前景

自动驾驶技术已经成为了交通运输领域的一项重要创新。它不仅在改善交通安全性和效率方面具有巨大潜力&#xff0c;还为各种商业应用提供了新的机会。本文将探讨自动驾驶在交通运输中的潜力&#xff0c;自动驾驶汽车的制造商和技术公司&#xff0c;以及自动驾驶的商业模式和市场…
阅读更多...
基于OpenCV批量分片高像素影像

基于OpenCV批量分片高像素影像

基于OpenCV批量分片高像素影像 为了更加精确的诊断和治疗&#xff0c;医疗影像往往是大像素&#xff08;1920x1080&#xff09;或超大像素图像&#xff08;4k图像4096x2160&#xff09;。这类图像的尺寸与深度学习实验数据常见尺寸&#xff08;227x227&#xff0c;或32x32&…
阅读更多...
OpenCV实现物体尺寸的测量

OpenCV实现物体尺寸的测量

一 &#xff0c;项目分析 物体尺寸测量的思路是找一个确定尺寸的物体作为参照物&#xff0c;根据已知的计算未知物体尺寸。 如下图所示&#xff0c;绿色的板子尺寸为220*300&#xff08;单位&#xff1a;毫米&#xff09;&#xff0c;通过程序计算白色纸片的长度。 主要是通过…
阅读更多...
最新文章

Copyright @ 2022~2023