Deeper into Go

已于 2023-01-12 06:53:46 修改
阅读量455 收藏
点赞数
分类专栏： Golang 文章标签： golang 开发语言 后端
于 2023-01-12 06:50:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011868279/article/details/128638712
版权
本文展示了Go语言中如何创建自定义类型（如卡片deck），使用函数接收者实现方法，处理切片操作，包括添加卡片、打印、洗牌以及保存和加载卡片数据到文件。此外，还涵盖了多值返回功能，用于发牌和分割牌堆，并探讨了随机数生成在洗牌算法中的作用。
摘要由CSDN通过智能技术生成

 OO Approach vs Go approach

Custom  Type Declaration

Functions with Receivers 

main.go

package main

func main() {
	cards := deck{"Ace of Diamonds", newCard()}
	cards = append(cards, "Six of Spades")

	 for i, card := range cards {

    	fmt.Println(i, card)
	 }

}

func newCard() string {

	return "Five of Diamonds"
}


package main

import "fmt"

// Create a new type of 'deck'
// which is a slice of strings
type deck []string

}

PS E:\software\golang\goprojects\goproject1\cards> ls


    Directory: E:\software\golang\goprojects\goproject1\cards


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         1/11/2023   6:49 AM            100 deck.go
-a----         1/11/2023   6:49 AM            260 main.go


PS E:\software\golang\goprojects\goproject1\cards> go run main.go deck.go
0 Ace of Diamonds
1 Five of Diamonds
2 Six of Spades
PS E:\software\golang\goprojects\goproject1\cards>

same as below

package main

func main() {
	cards := deck{"Ace of Diamonds", newCard()}
	cards = append(cards, "Six of Spades")

	// for i, card := range cards {

	// 	fmt.Println(i, card)
	// }

	cards.print()
}

func newCard() string {

	return "Five of Diamonds"
}


package main

import "fmt"

// Create a new type of 'deck'
// which is a slice of strings
type deck []string

func (d deck) print() {
	for i, card := range d {
		fmt.Println(i, card)
	}
}

PS E:\software\golang\goprojects\goproject1\cards> go run main.go deck.go
0 Ace of Diamonds
1 Five of Diamonds
2 Six of Spades
PS E:\software\golang\goprojects\goproject1\cards>

 

 Test your knowleges for Functions with Receivers

 

 

 Creating a New Deck

 main.go

package main

func main() {
	cards := newDeck()

	cards.print()
}

 deck.go

package main

import "fmt"

// Create a new type of 'deck'
// which is a slice of strings
type deck []string

func newDeck() deck {
	cards := deck{}

	cardSuits := []string{"Spades", "Diamonds", "Hearts", "Clubs"}
	cardValues := []string{"Ace", "Two", "Three", "Four"}

	for _, suit := range cardSuits {
		for _, value := range cardValues {
			cards = append(cards, value+" of  "+suit)
		}
	}

	return cards
}

func (d deck) print() {
	for i, card := range d {
		fmt.Println(i, card)
	}
}

PS E:\software\golang\goprojects\goproject1\cards> go run main.go deck.go
0 Ace of  Spades
1 Two of  Spades
2 Three of  Spades
3 Four of  Spades
4 Ace of  Diamonds
5 Two of  Diamonds
6 Three of  Diamonds
7 Four of  Diamonds
8 Ace of  Hearts
9 Two of  Hearts
10 Three of  Hearts
11 Four of  Hearts
12 Ace of  Clubs
13 Two of  Clubs
14 Three of  Clubs
15 Four of  Clubs
PS E:\software\golang\goprojects\goproject1\cards>

Slice Range Syntax

 Multiple Return Values

main.go 

package main

func main() {
	cards := newDeck()

	hand, remainingCards := deal(cards, 5)

	hand.print()
	remainingCards.print()
}

 deck.go

package main

import "fmt"

// Create a new type of 'deck'
// which is a slice of strings
type deck []string

func newDeck() deck {
	cards := deck{}

	cardSuits := []string{"Spades", "Diamonds", "Hearts", "Clubs"}
	cardValues := []string{"Ace", "Two", "Three", "Four"}

	for _, suit := range cardSuits {
		for _, value := range cardValues {
			cards = append(cards, value+" of  "+suit)
		}
	}

	return cards
}

func (d deck) print() {
	for i, card := range d {
		fmt.Println(i, card)
	}
}

func deal(d deck, handSize int) (deck, deck) {
	return d[:handSize], d[handSize:]
}

PS E:\software\golang\goprojects\goproject1\cards> go run main.go deck.go
0 Ace of  Spades
1 Two of  Spades    
2 Three of  Spades  
3 Four of  Spades   
4 Ace of  Diamonds  
0 Two of  Diamonds  
1 Three of  Diamonds
2 Four of  Diamonds 
3 Ace of  Hearts    
4 Two of  Hearts    
5 Three of  Hearts  
6 Four of  Hearts   
7 Ace of  Clubs     
8 Two of  Clubs     
9 Three of  Clubs   
10 Four of  Clubs   
PS E:\software\golang\goprojects\goproject1\cards>

Test Your Knowledge: Multiple Return Values

Question 1:

In the following code snippet, what will the value and type of 'title' and 'pages' be?

Question 2:

What will the following program log out?

 Question 3:

What will the following program log out?

Question 4:

Which of the following best explains the describe  function listed below?

 

 Byte Slices

main.go

package main

import "fmt"

func main() {
	cards := newDeck()
	fmt.Println(cards.toString())
}

 deck.go

package main

import (
	"fmt"
	"strings"
)

// Create a new type of 'deck'
// which is a slice of strings
type deck []string

func newDeck() deck {
	cards := deck{}

	cardSuits := []string{"Spades", "Diamonds", "Hearts", "Clubs"}
	cardValues := []string{"Ace", "Two", "Three", "Four"}

	for _, suit := range cardSuits {
		for _, value := range cardValues {
			cards = append(cards, value+" of  "+suit)
		}
	}

	return cards
}

func (d deck) print() {
	for i, card := range d {
		fmt.Println(i, card)
	}
}

func deal(d deck, handSize int) (deck, deck) {
	return d[:handSize], d[handSize:]
}

func (d deck) toString() string {
	return strings.Join([]string(d), ",")
}

Results:

PS E:\software\golang\goprojects\goproject1\cards> go run main.go deck.go
Ace of  Spades,Two of  Spades,Three of  Spades,Four of  Spades,Ace of  Diamonds,Two of  Diamonds,Three of  Diamonds,Four of  Diamonds,Ace of  Hearts,Two of  Hearts,Three of  Hearts,Four of  Hearts,Ace of  Clubs,Two of  Clubs,Three of  Clubs,Four of  Clubs
PS E:\software\golang\goprojects\goproject1\cards>

Saving Data to the Hard Drive

main.go

package main

func main() {
	cards := newDeck()
	cards.saveToFile("my_cards")
}

deck.go

package main

import (
	"fmt"
	"io/ioutil"
	"strings"
)

// Create a new type of 'deck'
// which is a slice of strings
type deck []string

func newDeck() deck {
	cards := deck{}

	cardSuits := []string{"Spades", "Diamonds", "Hearts", "Clubs"}
	cardValues := []string{"Ace", "Two", "Three", "Four"}

	for _, suit := range cardSuits {
		for _, value := range cardValues {
			cards = append(cards, value+" of  "+suit)
		}
	}

	return cards
}

func (d deck) print() {
	for i, card := range d {
		fmt.Println(i, card)
	}
}

func deal(d deck, handSize int) (deck, deck) {
	return d[:handSize], d[handSize:]
}

func (d deck) toString() string {
	return strings.Join([]string(d), ",")
}

func (d deck) saveToFile(filename string) error {
	return ioutil.WriteFile(filename, []byte(d.toString()), 0666)
}

Suffling a Deck

 

main.go

package main

func main() {
	cards := newDeck()
	cards.shuffle()
	cards.print()
}

 Deck.go

package main

import (
	"fmt"
	"io/ioutil"
	"math/rand"
	"os"
	"strings"
)

// Create a new type of 'deck'
// which is a slice of strings
type deck []string

func newDeck() deck {
	cards := deck{}

	cardSuits := []string{"Spades", "Diamonds", "Hearts", "Clubs"}
	cardValues := []string{"Ace", "Two", "Three", "Four"}

	for _, suit := range cardSuits {
		for _, value := range cardValues {
			cards = append(cards, value+" of  "+suit)
		}
	}

	return cards
}

func (d deck) print() {
	for i, card := range d {
		fmt.Println(i, card)
	}
}

func deal(d deck, handSize int) (deck, deck) {
	return d[:handSize], d[handSize:]
}

func (d deck) toString() string {
	return strings.Join([]string(d), ",")
}

func (d deck) saveToFile(filename string) error {
	return ioutil.WriteFile(filename, []byte(d.toString()), 0666)
}

func newDeckFromFile(filename string) deck {
	bs, err := ioutil.ReadFile(filename)

	if err != nil {
		// Option #1 - log the error and return a call to newDeck()
		// option #2 - log the error and entirely quit the program
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	s := strings.Split(string(bs), ",") // Ace of Spades, Two of Spades, Three of Spades,
	return deck(s)

}

func (d deck) shuffle() {
	for i := range d {
		newPosition := rand.Intn(len(d) - 1)

		d[i], d[newPosition] = d[newPosition], d[i]
	}
}

PS E:\software\golang\goprojects\goproject1\cards> go run main.go deck.go
0 Two of  Hearts
1 Ace of  Spades     
2 Three of  Spades   
3 Two of  Diamonds   
4 Ace of  Clubs      
5 Four of  Diamonds  
6 Three of  Hearts   
7 Three of  Clubs    
8 Ace of  Diamonds   
9 Four of  Hearts    
10 Four of  Spades   
11 Ace of  Hearts    
12 Two of  Spades    
13 Two of  Clubs     
14 Four of  Clubs    
15 Three of  Diamonds
PS E:\software\golang\goprojects\goproject1\cards>

Random Number Generation

package main

func main() {
	cards := newDeck()
	cards.shuffle()
	cards.print()
}

package main

import (
	"fmt"
	"io/ioutil"
	"math/rand"
	"os"
	"strings"
	"time"
)

// Create a new type of 'deck'
// which is a slice of strings
type deck []string

func newDeck() deck {
	cards := deck{}

	cardSuits := []string{"Spades", "Diamonds", "Hearts", "Clubs"}
	cardValues := []string{"Ace", "Two", "Three", "Four"}

	for _, suit := range cardSuits {
		for _, value := range cardValues {
			cards = append(cards, value+" of  "+suit)
		}
	}

	return cards
}

func (d deck) print() {
	for i, card := range d {
		fmt.Println(i, card)
	}
}

func deal(d deck, handSize int) (deck, deck) {
	return d[:handSize], d[handSize:]
}

func (d deck) toString() string {
	return strings.Join([]string(d), ",")
}

func (d deck) saveToFile(filename string) error {
	return ioutil.WriteFile(filename, []byte(d.toString()), 0666)
}

func newDeckFromFile(filename string) deck {
	bs, err := ioutil.ReadFile(filename)

	if err != nil {
		// Option #1 - log the error and return a call to newDeck()
		// option #2 - log the error and entirely quit the program
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	s := strings.Split(string(bs), ",") // Ace of Spades, Two of Spades, Three of Spades,
	return deck(s)

}

func (d deck) shuffle() {
	source := rand.NewSource(time.Now().UnixNano())
	r := rand.New(source)

	for i := range d {
		newPosition := r.Intn(len(d) - 1)

		d[i], d[newPosition] = d[newPosition], d[i]
	}
}

Writing a useful test

 

Go in Practice.pdf
09-06
Building upon the introductory concepts, Chapter 2 delves deeper into Go's core features and best practices. Topics covered include: - Advanced data types and structures - Error handling and panic ...
Web Development with Go(Apress,2015)
01-11
Demo web apps for attaining a deeper understandi ng of web development A reference REST API app which can be used to build scalable real-world backend services in Go. A through demonstration of ...
Inceptionism Going Deeper into Neural Networks
weixin_37958272的博客
03-02 239
Inceptionism: Going Deeper into Neural Networks 近年来，人工神经网络在图像分类和语音识别方面取得了显著的进展。但是，尽管这些都是基于众所周知的数学方法的非常有用的工具，但我们实际上对某些模型工作而其他模型不工作的原因却知之甚少。所以让我们来看看一些简单的技术来窥视这些网络。 我们训练一个人工神经网络，向它展示数以百万计的训练例子，并逐步调整网络参数，直到它给出我们想要的分类。该网络通常由10-30层人工神经元组成。每幅图像都被送入输入层，然后输入层与下一层对话
启发主义——深入神经网络（Inceptionism: Going Deeper into Neural Networks）
S20144144的博客
09-03 1718
传统的深度学习方法常用于根据数据标签学习分类、识别物体，或是学习数据或隐层的分布从而生成新的数据。而2015年提出的启发神经网络合成它想合成的图像，则开启了一种新的研究角度。之后开源的Deepdream则更是掀起了新的浪潮。下面我们翻译一下这篇论文。
Go deeper into semantic segmentation: 应用atrous convolution配合全连接CRFs的深度卷积网络 —— DeepLab V2
Jingyang.Zhang的博客
03-08 1911
目前为止语义分割的最经典框架DeepLab，后续很多分割框架也是根据其修改而来的。其构建思想的闪光点有很多，下面将会一一为各位读者讲解。感兴趣的同学可以参考原文：DeepLab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFs 创新点 – A
KV caching, a deeper look
bbbeoy的专栏
07-16 963
In the previous post, we introduced KV caching, a common optimization of the inference process of LLMs that make compute requirements of the (self-)attention mechanism to scale linearly rather than quadratically in the total sequence length (prompt + gener
论文精要解读：Going Deeper with Convolutions
SweetWind1996的博客
03-31 1609
本文都是作者自己对论文的理解，如有错误和不当之处，欢迎指正！一起学习，共同进步！
Golang并发编程 - sync包详解
ChineHe的博客
07-05 2890
​sync 包是 Go 语言标准库中提供的用于处理并发的包。它包含了各种用于同步和控制并发的工具，可以帮助开发者在多个 goroutine 之间安全地共享数据、协调执行顺序以及避免竞态条件等问题。本文详细对包下的各个结构体及其结构体方法进行了讲解，并给出了部分使用示例。
go语言 documentation
weixin_30871905的博客
09-25 224
Documentation文档 The Go programming language is an open source project to make programmers more productive. go语言是一个开源项目，是程序员开发更有效率。 Go is expressive, concise, clean, and efficient. Its concurrenc...
Going Deeper with Convolutions——GoogLeNet论文翻译
流年寂寞了沧桑的博客
01-04 3114
Going Deeper with Convolutions Abstract We propose a deep convolutional neural network architecture codenamed Inception that achieves the new state of the art for classification and detection in
Message Bus & Solace Deeper Dive
每一个不曾起舞的日子，都是对人生的辜负。
09-25 254
Distributed system design is hard. There are many decisions that you need to make in the architecture early that have long reaching impacts. One of these decisions is how systems will communicate.**I think that communication roughly falls into two schools:
tb8_Digging Deeper_Clustering_Standard Distributions_Forecasting_tableau + python_Season_Trends
Linli522362242的专栏
03-26 4771
The rapid visual analysis that is possible using Tableau is incredibly useful for answering numerous questions and making key decisions. But it only barely scratches[ˈskrætʃɪz]擦,刮,搔 the surface of the possible analysis. For example, a simple scatterpl...
【Go】切片
Freesia_2350的博客
03-21 493
go切片相关笔记
从零开始学习 Go 语言
九班长的博客
03-22 549
它以其简洁的语法、高效的并发支持和强大的标准库而闻名，非常适合开发高性能的服务器端应用、分布式系统和云计算工具。通过本文的学习，你可以掌握 Go 语言的基础语法、核心概念和开发工具，并能够使用 Go 语言开发实际项目。Go 语言以其简洁、高效和并发支持，成为现代软件开发的重要工具。通过本文的学习，你可以掌握 Go 语言的基础语法、核心概念和开发工具，并能够使用 Go 语言开发实际项目。无缓冲 Channel 的发送和接收操作是同步的，而有缓冲 Channel 的发送和接收操作是异步的。
使用 Go Colly 更改用户代理以进行网络抓取
最新发布
守城小轩的技术窝棚
03-25 759
1.1 Colly 是一款为 Gophers 打造的快速且优雅的爬取框架。它提供了简洁的接口，方便开发者编写各种类型的爬虫、抓取器或蜘蛛。借助 Colly，开发者能够轻松地从网站中提取结构化数据，这些数据可广泛应用于数据挖掘、数据处理或存档等领域。2.1 User Agent 是请求标头中的特殊字符串，服务器可通过它识别客户端的操作系统和版本、浏览器类型和版本等详细信息。2.2 对于普通浏览器，常见的 User Agent 字符串示例如下：Win64;Win64;x64;
【Go】map数据类型
Freesia_2350的博客
03-21 395
go语言map数据类型笔记
Golang 的 Waitgroup 锁用 Java的话要怎么实现？
zhanghaiou07657的博客
03-25 235
在 Go 语言里，主要用于等待一组 goroutine 完成执行。在 Java 中，与之功能对应的实现方式有多种，下面为你详细介绍。
3.1go流程控制语句
chxii的专栏
03-25 482
var 指针变量名称 *指针类型。
改写这段文字This paper investigates a phenomenon where query- based object detectors mispredict at the last decoding stage while predicting correctly at an intermediate stage. We review the training process and attribute the overlooked phenomenon to two limitations: lack of training emphasis and cascading errors from decoding sequence. We design and present Selective Query Recollection (SQR), a simple and effective training strategy for query-based object detec- tors. It cumulatively collects intermediate queries as decod- ing stages go deeper and selectively forwards the queries to the downstream stages aside from the sequential struc- ture. Such-wise, SQR places training emphasis on later stages and allows later stages to work with intermediate queries from earlier stages directly. SQR can be easily plugged into various query-based object detectors and sig- nificantly enhances their performance while leaving the in- ference pipeline unchanged. As a result, we apply SQR on Adamixer, DAB-DETR, and Deformable-DETR across various settings (backbone, number of queries, schedule) and consistently brings 1.4 ∼ 2.8 AP improvement.
03-08
本文研究了一种现象，即在预测中间阶段正确的情况下，在最后的解码阶段出现查询基础目标检测器误判的情况。我们回顾了训练过程，并将被忽视的现象归因于两个限制：缺乏训练重点和解码序列中的级联错误。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值