Introduction

I have seen many people coming from Python background struggling with Go. What I have obeserved it they write code that is limited to writing functions and calling them. They never leverage design constructs such as abstraction, encapsulation, inheritance, composition etc. I can understand their pain because I’ve been in the same boat.

In today’s post I’ll compare how we write classes in Python vs how we do the same thing in a Go way.

What is a class composed of?

1. Attributes in form of variables
2. Behavior in form of methods

Example in Python

Consider the following code in Python that defines a simple Person class with a name attribute and a greet method:

1
2
3
4
5
6
7
8
9

class Person:
    def __init__(self, name):
        self.name = name
    
    def greet(self):
        print(f"Hello, my name is {self.name}")

p = Person("John")
p.greet()  # prints "Hello, my name is John"

If you’re a Python programmer looking to learn Go, you’ll be happy to know that Go has a similar concept to classes called “structs”. Structs are similar to classes in that they allow you to define a custom data type with its own fields and methods.

Struct to define the structure and attributes

To define a struct in Go, you use the type keyword followed by the name of the struct and a set of curly braces containing the fields. Here’s an example of a simple struct called Person:

1
2
3
4

type Person struct {
    name string
    age  int
}

This defines a struct called Person with two fields: name and age, both of which are of type string and int respectively.

Method or behaviour using receiver function

You can also define methods on your structs by using the func keyword and attaching the method to the struct using the (p *Person) syntax, where p is the receiver of the method and Person is the type of the receiver. Here’s an example of a method called SayHello that prints a greeting to the console:

1
2
3

func (p *Person) SayHello() {
    fmt.Printf("Hello, my name is %s and I am %d years old\n", p.name, p.age)
}

To create an instance of a struct, you can use the new function or the shorthand syntax :=. Here’s an example of both:

1
2
3
4
5
6
7

// Using the new function
p1 := new(Person)
p1.name = "John"
p1.age = 30

// Using the shorthand syntax
p2 := Person{name: "Jane", age: 25}

You can also define a “constructor” function to create instances of your struct. This can be useful if you want to perform some initialization logic when creating a new instance. Here’s an example of a constructor function for the Person struct:

1
2
3
4
5
6

func NewPerson(name string, age int) *Person {
    p := new(Person)
    p.name = name
    p.age = age
    return p
}

You can then use this constructor function to create a new instance of the Person struct like this:

1

p := NewPerson("Bob", 35)

I hope this tutorial has helped you understand how to define and use structs in Go as a Python programmer. Structs are a powerful and flexible way to define custom data types in Go, and I encourage you to explore them further.

Thank you for reading!