DEV Community: tcs224

golang switch

tcs224 — Fri, 14 Feb 2020 20:50:28 +0000

If you want to evaluate cases in the Go programming language, you can use the switch statement. Like normal program execution, a switch statement is evaluated from top to bottom.

Instead of having a long list of if statements, a switch statement provides much cleaner code.

Switch example

The program below demonstrates the use of a switch statement. The switch statement exists in some other languages like C.

package main

import (
    "fmt"
)

func main() {
        x := 3

        switch x {
            case 0:
                fmt.Println("zero")
            case 1:
                fmt.Println("one")
            case 2:
                fmt.Println("two")             
            case 3:
                fmt.Println("tres")
        }
}

This outputs 'tres' because x is equal to 3. Instead of having a bulk of if statements you can use this.

The above program may not make sense, because we use a predefined condition. What if you you get it with keyboard input?

But instead of normal keyboard input, you need integer input. You can scan an integer like this:

fmt.Print("Enter x: ")
in := bufio.NewScanner(os.Stdin)
in.Scan()
x,_ := strconv.Atoi(in.Text())

So the switch statement with keyboard input gives:

package main

import (
    "fmt"
    "bufio"
    "os"
    "strconv"
)

func main() {
        fmt.Print("Enter x: ")
        in := bufio.NewScanner(os.Stdin)
        in.Scan()
        x,_ := strconv.Atoi(in.Text())

        switch x {
            case 0:
                fmt.Println("zero")
            case 1:
                fmt.Println("one")
            case 2:
                fmt.Println("two")             
            case 3:
                fmt.Println("tres")
        }
}

For a beginner in Python, which web framework would be the best to start learning first?

tcs224 — Fri, 14 Feb 2020 15:53:05 +0000

Did you know you can make web applications with Python?

You need a web framework or web module to do so. There are many frameworks available for this purpose: Flask, Django, Tornado, Bottle

Any of these frameworks will do, but the learning curve and popularity is very different. Picking the right framework is an essential decision, because it's easier to change a framework before you start a project than after you have 100s of code files.

Yes, you can do everything without a framework (manually), but for beginners that's not recommended and for professionals that's usually a waste of time.

Before learning a web framework, you should learn Python.

Popularity

You want to use a popular framework, because of available jobs, rich community and wide support and maintenance of the framework. See this survey (2009) from stackoverflow (not all are Python frameworks):

Flask and Django are the most popular Python frameworks. While Tornado and Bottle are simple, you probably want to go for the first two.

Django

Now Django isn't really suited for beginners in my opinion, it takes a lot of time to setup, but it's a good framework if you know what you are doing. There is a lot of documentation for the framework available [1][2]

Django is a more complete framework that is best suited for heavy back-end and thin front end (JavaScript) sites. It makes a lot of decisions for you, like by default it uses an ORM.

Flask

Flask on the other hand lets you start quickly and you'll gain an understanding of routing, templating, macros, and the markup language used in the Python web framework.

You can build large sites with Flask, for example the popular website Pinterest was created with Python Flask.

Flask is an extremely lightweight web framework. I would recommend learning this, because not only it will gain you an understanding of we frameworks but you will learn more about Python than if you use larger projects like Django.

Related links:

Why Flask?

tcs224 — Thu, 13 Feb 2020 19:30:08 +0000

Flask lets you build web apps with Python. It lets you build both simple and complex web apps (what is Flask).

I like it over Django because you are in full control of the architecture choices. But of course, you should make your own choices. Perhaps you prefer Tornado

Django makes a lot of choices for you, like that you have to use an ORM (Object-relational mapping). In general I prefer having raw SQL queries than using an ORM.

Flask was made several years after Django and therefore learned from the Python community's reactions.

Why Flask

There are many reasons to choose Flask. For one it's a microframework, so you can learn it quite fast. Some other reasons to choice Flask are:

Flask is actively maintained and developed
It is extensible while maintaining a simple core
The documentation is great
It's easy to get started with Flask as a beginner. There is a tiny boilerplate code for getting a simple app up and running.
It saves you development time (Easy to deploy Flask apps)

Flexibility

It has a template engine available (Jinja2) but you are not forced to use it. If you prefer using your own engine, you can with Flask. This flexibility is one of the great things about Flask.

In fact, if you want to return just plain html you can.

@app.route('/')
def root():
    return app.send_static_file('index.html')

It relies on a plug-gable approach, the developer can include the modules he or she needs for the project.

Conclusion

Flask is great (in my opinion), but you should use what makes most sense to you. If you already have a project in another framework, it may not be the best idea to rewrite the whole code.

Related links:

Go while loop

tcs224 — Thu, 13 Feb 2020 14:35:23 +0000

If you programmed in other programming languages before, you may be familiar with a while loop. So you'd think you can use a while loop in Golang. But in Go, things are bit different.

Go doesn't have the while keyword, instead in Go for is Go's "while".
So instead of having something like this:

while sum < 10:
    sum += sum

You have to use for in Go, when you want to use a while loop (this is confusing if you programmed in other languages before):

sum := 1
for sum < 10 {
    sum += sum
}

Of course you need to put in a function (the main function, which is the first function on execution) and write "import fmt", which is a module required for screen output (Println).

package main

import "fmt"

func main() {
    sum := 1
    for sum < 10 {
        sum += sum
    }
    fmt.Println(sum)
}

This outputs the result, as if you used a while loop in another language:

16

Program exited.

Related links:

python hashing

tcs224 — Thu, 13 Feb 2020 13:56:53 +0000

In Python, as in many other languages, you can make use of a hash function. A hash function is a one way function that takes input of a variable length ( a byte string ) and converts it to a fixed length sequence.

So if f is a hashing function, calculating f(x) is easy but the other way around will take years and years. Please note that hashing is not encryption, it doesn't make use of (private) keys.

This is very useful when you want to store passwords on a computer, to prevent leaks you hash them. In practice this doesn't always happen, and some companies store passwords in plain text which is a security risk.

Before playing with hashing, you should know the basics of Python

Example

Example: if you use the sha256 hashing function, with several inputs:

"Hello world" hashed becomes

'64ec88ca00b268e5ba1a35678a1b5316d212f4f366b2477232534a8aeca37f3c'.

If instead you use "Hello World" (capital W) you get:

'2161447856ce2af91e8b7efa6cfbad572f775609925f492e962ba8a7408d6b19'

So a small change in input is a large change in output. In Python you can do hashing with the module hashlib.

>>> import hashlib
>>> m = hashlib.sha256()
>>> m.update(b"Hello World")
>>> m.hexdigest()

There are many hashing algorithms, to see the ones included with your hashlib version type

>>> import hashlib
>>> print(hashlib.algorithms_available)
{'blake2b512', 'shake_256', 'sha3-224', 'blake2s256', 'sha3-512', 'shake256', 'sha3-256', 'shake128', 'sha3_224', 'sha1', 'sha512', 'sha512-256', 'sha224', 'blake2b', 'shake_128', 'sha384', 'md5-sha1', 'md4', 'sha512-224', 'whirlpool', 'sm3', 'md5', 'sha3-384', 'sha3_256', 'sha256', 'sha3_384', 'sha3_512', 'blake2s', 'ripemd160'}
>>>

If you run the code below, you'll see a different hash for the same output, because they are different hashing algorithms.

>>> print(hashlib.md5(b'Hello World').hexdigest())
>>> print(hashlib.sha1(b'Hello World').hexdigest())
>>> print(hashlib.sha224(b'Hello World').hexdigest())
>>> print(hashlib.sha256(b'Hello World').hexdigest())
>>> print(hashlib.sha384(b'Hello World').hexdigest())
>>> print(hashlib.sha512(b'Hello World').hexdigest())
>>> print(hashlib.blake2s(b'Hello World').hexdigest())

Be careful with using md5 and sha1 as they are deprecated.

Related links:

golang playground

tcs224 — Wed, 12 Feb 2020 14:04:28 +0000

Go is an open source programming language that makes it easy to build simple, reliable, and efficient software. Do you want to start with Golang as quick as possible?

You can use the online go playground. This lets you run Go programs right from your web browser.

If you prefer having golang on your computer, you can install Golang on your pc. While it may take some time to install, you can then use your favorite IDE with golang.

Go playground

The go playground presents you with an interface where in yellow pane where you can type your Go code. It already shows some code when opening:

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello, playground")
}

This is a basic program that you can run, but you can change the code if you want to. On top there is the navigation, click run to run the Go program.

You'll see it output the current program below the yellow pane.

By default it runs the hello world program. There's a share button in the go playground, which lets you share your code online.

So where to go from here?

You could try some go tutorials like the golang tour or a traditional tutorial.

python server socket

tcs224 — Wed, 12 Feb 2020 13:13:15 +0000

In Python you can do network programming. You may be familiar with network programming at high level (the web, ftp).

This uses the client-server model, where the server sends the data (web, ftp) and the client is your computer. Upon typing the website url, the web data is returned from the web server.

On the web, every web browser is a client and every website runs on a server. Typically there are many web browsers connecting to the same server (website).

But did you know you can program low-level and create your own protocols?

Welcome to the world of sockets. You can use sockets to create your own server or client. Before playing with Python, you should know the basics of Python

Socket server

Lets create your own socket server. You can do this by following a few steps:

import sockets
define host and port
wait for client
parse client data (and send)

First import the sockets module:

import socket

Then define the host and port

HOST = ''                 # Symbolic name meaning all available interfaces
PORT = 50007              # Arbitrary non-privileged port

Open the server and wait for a client:

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(1)
conn, addr = s.accept()
print 'Connected by', addr

Then you can wait for data (or send data) and parse it according to your protocol. Data could be in plain text, json, xml or any other format. If you are implementing an existing protocol, you should use the one defined.

while 1:
    data = conn.recv(1024)
    if not data: break
    conn.sendall(data)
conn.close()

That's all there is to it to startup a server. Make sure your firewall isn't blocking the server and that you have the user permissions to open a server.

Telnet client

If your server is running, open a new terminal. In the new terminal you can use telnet to connect to the server

telnet 127.0.0.1 50007

Where 127.0.0.1 is your computer (loopback ip) and 50007 is the port you opened in the server program. Once connected try to send some data and take a look at your server terminal. If you need to, you can also create a socket client in Python.

Related links:

f-Strings in Python

tcs224 — Tue, 11 Feb 2020 20:58:39 +0000

If you programmed in Python before, you probably know how to use strings. You also know that formatting can be quite cumbersome, using %-formatting makes it look not elegant:

$ python3
Python 3.7.3 (default, Apr  3 2019, 05:39:12) 
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> name = "Veronica"
>>> "Hello %s" % name
'Hello Veronica'

To use multiple variables, it already starts looking cryptic

>>> name = "Veronica"
>>> age = 25
>>> "I am %s and I am %i years old." % (name,age)
'I am Veronica and I am 25 years old.'
>>>

%-formatting isn't that great, it becomes unreadable with a lot of parameters. Consider this example with manay parameters:

>>> name = "Veronica"
>>> age = 25
>>> lastname = "Sofia"
>>> job = "Teacher"
>>> relation = "Single"
>>> "Im %s %s, Im %i years old and a %s. Im %s" % (name,lastname, age,job,relation)
'Im Veronica Sofia, Im 25 years old and a Teacher. Im Single'
>>>

f-Strings

In Python >= 3.6 there's f-Strings. They make life much easier. To define one, you need to put an f in the beginning.

Take a look at these examples using f-Strings:
For two variables:

>>> f"Hello {name}. I am {age}"
'Hello Veronica. I am 25'

With multiple variables:

>>> f"Im {name} {lastname}, Im {age} years old and a {job}. Im {relation}"
'Im Veronica Sofia, Im 25 years old and a Teacher. Im Single'
>>>

Related links:

python for the web

tcs224 — Tue, 11 Feb 2020 17:06:34 +0000

You can use the Python programming language to build web apps. These web apps then run server-side and the user is presented with the traditional web app (HTML, JavaScript, Angular, Vue).

Python doesn't have a built-in web framework, so you have to pick one. A web framework starts a server, does templates, deals with architecture (often model-view-controller) and so on. It saves you a lot of development time. Web frameworks can be installed with pip

pip install <framework>

Web Frameworks

A popular micro-framework is Flask (hello world example). This does the bare minimum, run the server, routing, parse templates, pass variables etc.

If you want to have many features available in the framework, like an ORM (Object Relational Manager) you could go for Django (django tutorial). Downside of Django is the learning curve and it has many features you may not need.

Tornado is another option you could pick. It is a Python web framework and asynchronous networking library. Tornado apps are scale-able, it can scale to tens of thousands of open connections.
You can install tornado with pip

pip install tornado

It's very straightforward to create a hello world app:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

It opens the server at port 8888, then waits for input. It creates one web route (/) which is linked to MainHandler. This returns the text "Hello, World".

Hosting

To get your app online, you have to host it on a server. You could open your home server to the web, but this is generally not a good idea.

An easy way to do hosting is to use PythonAnywhere. This lets you host, run and code in the cloud.

If you want to do everything yourself, you could use Vultr or Digital Ocean instead.

golang break for loop

tcs224 — Tue, 11 Feb 2020 16:30:06 +0000

In Go you can use a for loop to repeat code. The for loop exists in many programming languages. But how do you stop a for loop?

By default, it stops if a condition is true. In Go, this repeats while i is smaller than 5. If its greater it stops.

for i := 0; i < 5; i++ {

This works well, but what if conditions are not right? Like this:

for i := 0; i > -1; i++ {

Then it keeps repeating over and over.

Infinite loop

An infinite loop is a loop the stays in the loop indefinitely. In Golang you can create this type of loop:

for {

So when would this for loop end?

package main

import "fmt"

func main() {
    i := 0
    for {
        fmt.Println("i is:", i)
        i++;
    }
    fmt.Println("Statement after for loop.")
}

It doesn't end by default, this creates an infinite loop in Go. So this outputs..

...
i is: 59641
i is: 59642
i is: 59643
i is: 59644
i is: 59645
...

ad infinitum.

Break keyword

To get out of the loop, you can use the break keyword. The break exits the infinite loop, but it has to do so conditionally.

if i >= 10 { break }

So that would give you the code:

package main

import "fmt"

func main() {
    i := 0
    for {
        if i >= 10 { break }
        fmt.Println("i is:", i)
        i++;
    }
    fmt.Println("Statement after for loop.")
}

Related links:

for key value in dict python

tcs224 — Tue, 11 Feb 2020 14:32:01 +0000

How to print keys and values in a dictionary? Wait.. what is a dictionary?

In the Python programming language, a dictionary is a one to one mapping. Its a set of key-value pairs. Each key is mapped to one and only one value.

You can run two key operations on a dictionary: store a value with some key and extract the value given the key.

In other programming languages a dictionary is sometimes called "associative memories" or "associative arrays".

Example

In Python, an empty dictionary would be defined with curly brackets.

x = {}

Do not confuse with lists, which use another type of brackets [].

A simple dictionary would be defined like this, with every pair separated by a comma and every key-value pair linked using a colon:

my_dict = { "name":"Alicia", "city":"Toronto", "country":"Canada"}

Print dictionary with for loop

One way to print the values in a dictionary is to use a for loop.

import json

my_dict = { "name":"Alicia", "city":"Toronto", "country":"Canada"}

for item in my_dict:
    print("({}->{})".format(item,my_dict[item]))

The program then outputs the key->value mapping for each pair in the dictionary:

(city->Toronto)
(name->Alicia)
(country->Canada)

Print dictionary with item() method

You can use the .items() method to get the key,value from a dictionary. In my opinion this is easier to read.

This also has the advantage of having both the key and value available in a clear way inside the for loop. It's good for readability of your program.

import json

my_dict = { "name":"Alicia", "city":"Toronto", "country":"Canada"}

for key,value in my_dict.items():
    print("({}->{})".format(key,value))

Print using keys

Another way to output a dictionary is to get all keys and use the keys to output the key-value pairs.

In every iteration, the key is used to get the value in the dictionary. Note that this is the same as the first method, but with explicit definition of key.

import json

my_dict = { "name":"Alicia", "city":"Toronto", "country":"Canada"}

for key in my_dict.keys():
    print("({}->{})".format(key,my_dict[key]))

Related links:

parse json with python

tcs224 — Mon, 10 Feb 2020 19:15:47 +0000

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write.

Usually web apps transfer JSON data back and forth. If you create your own web apps, they likely transfer JSON data (or XML). If you want to play around with the json format, here's a tool

So how do you work with Python and JSON?

First, you should already know the basics of Python programming.

Python and JSON

Python has a module named json. This lets you convert json data from the web to python objects and vice versa.

Consider this example in the Python interpreter:

>>> import json
>>> # json data
... 
>>> x = '{ "name":"Alicia", "age":30, "city":"Toronto"}'
>>> # prase json data
... 
>>> obj = json.loads(x)
>>> print(obj["name"]
... )
Alicia
>>> print(obj["city"])
Toronto
>>>

It loads the json module, defines raw json data. Then converts the json data to a python object.

>>> obj = json.loads(x)

And then you can use it as Python object

>>> print(obj["name"])
>>> print(obj["city"])

You can load JSON data from a url or from a file.

Parse JSON

You've seen this above in the Python REPL, but for clarity lets put it in a code file. In code, to load json data and convert it to a Python object, you can do this:

import json

# json data                                                                     
data = '{ "name":"Alicia", "age":30, "city":"Toronto"}'

# parse json data                                                               
obj = json.loads(data)

# python object                                                                 
print(obj["name"])
print(obj["city"])

Save it as example.py and run it, you'll see it has been converted to a Python object. You can also decode a Python object to JSON amongst other things.