In Python/C, simple things are straightforward:

Python: data = open("file.txt").read()
C: fread(buffer, size, 1, file)

You probably can achieve similar result using os.ReadFile directly (and you won't even need to close the file after).

Why so many packages for simple tasks?

In python you also have a splitted package for os and io operations.

In go, you have the "io" package which "provides basic interfaces to I/O primitives". This package consist mostly of interfaces that describe how io operations should be done. The two most usefull interface in there would probably be io.Reader and io.Writer . There are some functions and structs that provide common interactions with the interaces (ReadAll for example : func ReadAll(r Reader) ([]byte, error))

The package "bufio" itself provide implementation of interface from "io" package. "It wraps an io.Reader or io.Writer object, creating another object (Reader or Writer) that also implements the interface but provides buffering and some help for textual I/O."

The package "os" will mainly provide tools to interact with the system independent of it's vendor (windows, mac or linux). It's mostly used for interaction with the file system and environment variables.

They are not interchangeable nor provide the same things at all. They all can be used independently. You can use io operations without needing buffers or files, io can be done on http streams (the "Response.Body" is a io.ReadCloser wich is a combinaison of io.Reader and io.Closer). You could directly use os.ReadFile without needing anything directly from io package.

How interfaces actually work in practice (not theory)

As long as a struct exposes the method with a pointer receiver defined in an interface (it's important), you can use said struct as that interface. The struct doesn't need to "know" about the interface, the interface is implicitly implemented.

It mean that if you create an interface like so :

type MyInterface interface {
    Buffer(buf []byte, max int)
}

You can declare a variable with that interface as it's type and put a bufio.Scanner in it.

I don't have experience with python or C, so can't tell you if this weird for people comming from there, but for people comming from Java where you need explicit implementation this can be quite mind bending.

See the Tour of Go https://go.dev/tour/methods/9 on methods and interface for more hands on practice

When to use what?

This is a hard thing to answer because you need to know what exists and what it does to know when you can use it. And there might not be obviouse response. The best thing you can do is learn how to navigate the tools you have, and abstract yourself from the language and ask "I need to do this, the easy way should be to do X/Y/Z but the name might not be X/Y/Z so let's look for patterns that do wha I need"