Study Golang as a Python Developer

Studying Go or Golang as a Python developer, programmer or software program engineer is simpler than you assume.

Whereas there are various issues to be taught and get aware of, there are various advantages and plenty of widespread traits.

Why be taught Go as a Python developer

I discover Python to be a really highly effective and helpful programming language, having used it on a variety of tasks for a fair wider vary of duties. From Platform Engineering automation to Machine Studying and Synthetic Intelligence, to constructing Consumer Interfaces and creating APIs in addition to constructing complete web sites and net functions. Python has served me nicely and can proceed to take action.

Nevertheless, there are causes for studying a brand new language, and Go has stuffed a void for me, particularly on the subject of having the ability to distribute and share my functions each throughout platforms in addition to having the ability to run compiled code. Which as everyone knows, is often a lot quicker than code that’s merely interpreted.

So quicker code that we will additionally distribute as a static binary. Let’s get began!

Getting began

The primary apparent factor to get began is to be sure to have Go put in in your pc, or whichever machine you propose on doing the event on.

You could possibly at all times go for utilizing a web based editor or IDE, however having the ability to do every part by yourself machine might be higher. It offers you a extra rounded view on methods to get the entire system prepared and teaches you any of these lacking items it’s possible you’ll not in any other case pay attention to.

Find out how to Obtain Go

You may obtain Golang from the Go web site over at

In the event you’re on a Mac, as I’m, I might advocate utilizing Homebrew to put in and handle Go (and just about every part else..).

If that’s the case, simply sort brew set up go, or brew improve go if you have already got Go put in and wish to be sure to’re on the most recent, slickest model. I’m at present on model 1.14.

Utilizing Go in an IDE/editor

VS Code has turn out to be my editor of selection over the previous two or three years, you may get it right here:

It’s light-weight, quick, and has entry to completely a great deal of extensions to make it higher in each means.

As a software program engineer for a lot of, a few years, I’ve modified editors extra occasions than I care to recollect. To this point, VS Code retains me fairly joyful.

Establishing VS Code and including the Golang Extensions

Inside VS Code, click on on the Extensions icon on the left-hand bar, and sort Go into the search bar.

In the event you set up this extension, you’re going to get all the first advantages you want!

Let’s not waste any extra time…

Find out how to Begin a Undertaking

Go makes use of a factor known as Go Modules to organise code, it’s a significantly better various to utilizing Go’s $GOPATH insanity of Go model < 0.13. In case you are not aware of it, that’s high-quality, you don’t should be to finish this tutorial. We’ll utterly keep away from all of the craziness of it at this time.

You may be sure to’re on a required model by typing in go model within the command-line. This could return a string saying one thing like:
go model go1.14 darwin/amd64.

Begin by making a working listing:

mkdir -p ~/src/mygoproject && cd $_

Now create a git repository and provoke the undertaking:

git init -q
git distant add origin 

Subsequent, we get to provoke our undertaking’s major module. That is necessary should you ever wish to import any further native recordsdata or packages.

go mod init

This may create a file in our undertaking root listing known as go.mod, which is able to now include the next code:


go 1.14

At this level, we will open our undertaking in VS Code, which may simply be carried out by typing code . to load the present listing.

In case your CLI complains saying it doesn’t know what the code key phrase is, then you will have so as to add it. To do that, open VS Code and press cmd+shift+p, then sort set up, you will notice the Set up 'code' command in PATH, as beneath:

As soon as that is carried out, you will have to reload your terminal window for the $PATH variable to be up to date.

Writing your first Go code

Create a file known as essential.go.

We’ll enter all our code on this file in the intervening time.

Each Go file begins with a bundle <packagename> file. As a result of that is the entry level, we are going to name it essential.

bundle essential

Each Go utility begins with a reserved operate title known as essential(). Features are outlined by the func key phrase, that is equal to the def key phrase in Python.

bundle essential

func essential() {
	// our entry operate

At this level, we now have absolutely the naked necessities for our Go utility. This does completely nothing but, however we will execute it with none errors.

Operating a Go undertaking from the command-line

In Python, you’ll sort python and it might execute that file.

In Go, you employ the go key phrase together with the command you want to set off. go run filename.go does the identical factor and masses and runs the file you will have specified.

To make issues just a little simpler for us, once we begin together with further recordsdata, we choose to execute our utility by issuing a go run . as a substitute. This may load all Go code inside this undertaking, search for the essential() technique and run it.

If we do that with the above code, it is going to exit with none errors. It is because we aren’t but doing something wonderful.

Let’s add an everyday print("Good day world"), like we might do in Python.

In Go, we use the fmt module to offer us with the power to print to the display screen.

Regulate your essential.go file so as to add these related items:

bundle essential

import "fmt"

func essential() {
	// our entry operate
	fmt.Println("Good day world")

If we run our undertaking once more, as we did earlier than, we are going to now get the string rendered to the CLI:

go run .

# Good day world

Splitting code into Features

Features in Go work principally the identical as how they do in Python, with just a few exceptions, reminiscent of enter and return sorts.

In Python, we may write a operate like this:

# Soak up 2 variables and return the concatenated end result
def my_function_name(var1, var2):
    return var1 + var2

# use this operate
print(my_function_name(1, 2))

# prints: 3

To do the identical in Go, we may do one thing like this:

// We have to outline the variable sorts: (var1 int, var2 int)
// Additionally should explicity declare the return sort: int
func my_function_name(var1 int, var2 int) int {
    return var1 + var2

// use this operate
fmt.Println( my_function_name(1, 2 ) )

// prints: 3

We will see that it’s fairly a bit easier in Python, as variables are implicit. Nevertheless, in Go we now have to explicitly declare the enter and output sorts.

Quickstart to Variables

Python comes filled with just a few very helpful variable sorts, these might be summed up as:

Numbers, String, Listing, Tuple, Dictionary

Whereas in Go, we now have:

  1. **Primary sort: **Numbers (integers, floats, complicated), strings, and booleans
  2. **Mixture sort: **Array and structs
  3. **Reference sort: **Pointers, slices, maps, capabilities, and channels
  4. Interface sort

Whereas issues get much more difficult than this, it’s good to know we now have some choices to match to our Python commons.

Find out how to Import Extra Recordsdata

Go model 1.11 launched modules, and extra not too long ago it has been popularised as being prepared for manufacturing.

That is nice information, as beforehand, we must use the $GOPATH file construction to retailer all Go tasks inside one huge listing.

We created a module at the start of this tutorial and made positive to path it on to our git repository, this was all on objective!

Let’s add one other file to our undertaking, put some code in it and discover ways to import and name it in our essential.go file.

Create a listing known as extras and a file in there known as extrafile.go

In extrafile.go add the next code:

bundle extras

// The operate title HAS TO begin with a capital letter
// .. if you would like it to be accessible exterior this file
func HelloFromExtras() string {
	return "Good day From Extras!"

Notice the bundle extras on the prime, this is identical title because the listing this file is in. No matter what the filename is.

Now from our essential.go file, we will embrace this bundle. That is how our essential.go file appears as soon as extras is imported:

bundle essential

import (

func essential() {
	// our entry operate

See how we now have imported our further bundle by its listing title off the again of the module we initialised our undertaking as.

Now we have then printed out the HelloFromExtras technique. We may additionally alias the bundle as follows if we wished to make use of it below a unique title. That is the case if our bundle occurs to make use of a typical or overridden title that already exists in our total undertaking someplace else.

bundle essential

import (
	ourfile ""

func essential() {
	// our entry operate

If we run this from the CLI, utilizing go run ., we should always see:

go run .

# Good day From Extras!

The necessary issues to recollect listed below are:

  • All the time use modules and module paths
  • Go doesn’t have public and non-public technique sorts when sharing. As a substitute, capitalise the primary letter of a way title if you would like it to be public, in any other case preserve it lowercase if you would like it to be non-public, or solely accessible by the identical file.

func thisIsAPrivateMethod()

func ThisIsAPublicMethod()

Compiling your undertaking

Python is an interpreted language, and as such you by no means want to fret about compiling any code. Merely write the code and use the python CLI to run it. Whether or not you do that utilizing a Python Digital Atmosphere or obtain it another means.

Golang code is a lot quicker than Python code as a result of it’s compiled all the way down to static binaries. Which means that it doesn’t require a digital machine or runtime to execute. That is notably helpful if you’re sharing your utility with others who don’t have the supply code.

You should use the construct key phrase from the CLI to construct your binary:

Our undertaking construction appears like this earlier than we construct:

Now we run go construct . which is able to create an extra file for us:

Compiling Go tasks is extremely quick, particularly should you’re coming from the C, C++, C# or Java world. As a Python developer, this may increasingly all be new to you. Don’t fear although, it’s not rather more difficult than what you’ve simply seen!

We’re now carried out and may execute our binary file from the CLI as we might count on to:


# Good day From Extras!

Pushing to Github

At this stage, we now have initialised our undertaking and added a few totally different recordsdata to it.

Nevertheless, we haven’t model managed it but.

We known as the first module and even added a git distant add origin in the beginning.

To push our code to Github, we’d like to verify we now have created the above repository and have carried out a git add . (add whichever recordsdata you wish to model), then a:
git commit -m "<your_message_name>"

As soon as that is carried out, merely run a git push origin grasp and also you’re carried out!

Closing ideas

Whereas this tutorial touches on the getting began factors of utilizing Golang for Python builders, I can be writing many extra superior tutorials over the approaching days and weeks.

In case you are fascinated about studying methods to use Golang as knowledgeable software program engineer and wish to turn out to be an knowledgeable with the language, then contemplate becoming a member of the mailing checklist which is distributed out as soon as every week.

Related Articles


Please enter your comment!
Please enter your name here

Latest Articles