DEV Community: toebes618

Django model

toebes618 — Wed, 04 Mar 2020 22:12:23 +0000

Django supports a variety of databases, including PostgreSQL, MySQL, SQLite, Oracle.

Django provides a unified call API for these databases. We can choose different databases based on our own business needs.

MySQL is the most commonly used database in web applications. We'll cover Mysql as an example in this section. You can learn more about the basics of Mysql in this site.

If you don't have mysql driver installed, you can perform the following command installation:

sudo pip install mysqlclient

If you are new to Django, this is a good Django course

Database configuration

We set the DATABASES configuration in the project's settings.py file and changed its information to:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'test',
        'USER': 'test',
        'PASSWORD': '****yourpassword****',
        'HOST':'localhost',
        'PORT':'3306',
    }
}

It contains database names and user information, which are the same as the corresponding database and user settings in MySQL. Based on this setting, Django connects to the appropriate databases and users in MySQL.

Defining a model

Django states that if you want to use a model, you must create an app. We use the following command to create an app for TestModel:

python manage.py startapp TestModel

The directory structure is as follows:

HelloWorld
|-- TestModel
|   |-- __init__.py
|   |-- admin.py
|   |-- models.py
|   |-- tests.py
|   `-- views.py

We modify the TestModel/models.py file with the following code:

HelloWorld/TestModel/models.py: file code:

# models.py
from django.db import models

class Test(models.Model):
    name = models.CharField(max_length=20)

The above classes represent the database name and inherit models. Model, the fields inside the class represent the fields in the data table (name), and the data types are defined by CharField (equivalent to varchar) and the max_length parameters.

Next, find this INSTALLED_APPS in settings.py, as follows:

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'TestModel',
)

Run on the command line:

Note: In Django 1.9 and future versions use migrate instead of syscdb.

$ python manage.py migrate
$ python manage.py makemigrations TestModel
$ python manage.py migrate TestModel

You'll be able to create your data sheet with a few lines of the words "Creative table...".

Creating tables ...
…… 
Creating table TestModel_test
……

The table name is composed of: app name, class name (e.g., TestModel_test).

Note: Although we didn't set the primary key to the table in models, Django automatically adds an id as the primary key.

Database operations

Next, we add testdb.py files in the HelloWorld directory and modify urls.py:

from django.conf.urls import *
from HelloWorld.view import hello
from HelloWorld.testdb import testdb

urlpatterns = patterns("",
        ('^hello/$', hello),
        ('^testdb/$', testdb),
)

Add data

Adding data requires creating an object before executing the save function, which is equivalent to INSERT in SQL:

from django.http import HttpResponse
from TestModel.models import Test

def testdb(request):
  test1 = Test(name='dev.to')
  test1.save()
  return HttpResponse("<p>saved</p>")

Visit /testdb/ you can see a hint of success in adding data. If you want you can verify this in the MySQL database table.

Get data

Django provides a variety of ways to get the contents of the database, as shown in the following code:

HelloWorld/HelloWorld/testdb.py: File code:

from django.http import HttpResponse
from TestModel.models import Test

def testdb(request):
    response = ""
    response1 = ""

    # Get all the data the all() method, this is equivalent to SELECT * in SQL.  
    list = Test.objects.all()

    # Filter is equivalent to WHERE in SQL
    response2 = Test.objects.filter(id=1) 

    # Get a single object
    response3 = Test.objects.get(id=1) 

    # Limit returned data equivalent to OFFSET 0 LIMIT 2 in SQL
    Test.objects.order_by('name')[0:2]
    Test.objects.order_by("id")
    Test.objects.filter(name="dev.to").order_by("id")

    # Output all data
    for var in list:
        response1 += var.name + " "

    response = response1
    return HttpResponse("<p>" + response + "</p>")

Update data

Modifying data can be made using save() or update():

HelloWorld/HelloWorld/testdb.py: File code:

from django.http import HttpResponse

from TestModel.models import Test

def testdb(request):
    # equivalent to UPDATE in SQL
    test1 = Test.objects.get(id=1)
    test1.name = 'dev.to'
    test1.save()

    # Another way
    #Test.objects.filter(id=1).update(name='dev.to')

    # Modify all columns
    # Test.objects.all().update(name='dev.to')

    return HttpResponse("<p>Updated</p>")

Delete data

Simply call the delete() method of the object in the database by deleting it:

HelloWorld/HelloWorld/testdb.py: File code:

from django.http import HttpResponse

from TestModel.models import Test

def testdb(request):
    # Delete data where id=1
    test1 = Test.objects.get(id=1)
    test1.delete()

    # Another way
    # Test.objects.filter(id=1).delete()

    # Delete all data
    # Test.objects.all().delete()

    return HttpResponse("<p>Deleted</p>")

What is Go?

toebes618 — Wed, 04 Mar 2020 00:50:02 +0000

Go is an open source programming language that makes it easy to construct simple, reliable, and efficient software.

Go was developed in late 2007 by Robert Griesemer, Rob Pike, Ken Thompson, and later joined Ian Lance Taylor, Russ Cox and others, and was eventually released in November 2009.

A stable version of Go 1 was released earlier in 2012. Now Go's development is completely open and has an active community.

Go Language Features

Simplicity, fastness and security
Parallel, fun, open source
Memory management, v array security, fast compilation

Go Language Use

The Go language is designed as a system programming language for giant central servers with Web servers, storage clusters or similar uses.
For high-performance distributed systems, the Go language is undoubtedly more efficient than most other languages. It provides massive parallel support

First Go program

Let's write the first Go program, hello.go (the extension of the Go language source file is .go), with the following code:

package main

import "fmt"

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

Execute the above code outputs

$ go run hello.go 
Hello, World!

Python Network Programming

toebes618 — Tue, 03 Mar 2020 16:11:00 +0000

You can do network programming in Python, which is quite common because it's so quick to write a Python script.

If this article seems hard, don't worry it's not. But you should know the Python basics before trying to make network scripts.

Python offers two levels of access network services.

Low levels (think byte level) of network service to support basic Socket, which provides a standard BSD Sockets API, you can access all the methods underlying operating system Socket interface.
high level (think existing protocols) like web, ftp, mail. If you want to use an existing internet protocol, scroll to the table below.

What is Socket?

Socket also known as "sockets", the process between the hosts or between a computer can communicate.

Simple example

Server

We use the socket module and then the socket() function to create a socket object.
Then define a port.

Now we can call bind(hostname, port) function to specify the service (port).

Then, we call accept() method. The method waits for the client connection, and returns a connection object representing a client is connected to.

The complete code is as follows:

    # File name: server.py

    import socket # Import socket module

    s = socket.socket () # Create a socket object
    host = socket.gethostname () # get local host name
    port = 12345 # Set the port
    s.bind((host, port)) # Bind port

    s.listen(5) # connection requests from clients
    while True:
        c, addr = s.accept () # client connection.
        print('connection address:', addr)
        c.send('Welcome to dev.to!')
        c.close() # close the connection

Client

Next we write a simple client to connect to the service instance created above. Port number is 12345 (same as server).

The socket.connect (hosname, port) method opens a TCP connection to the server.

After connecting we can server data. Remember, after the completion of the operation need to close the connection.

The complete code is as follows:

    # File name: client.py

    import socket # Import socket module

    s = socket.socket() # Create a socket object
    host = socket.gethostname() # get local host name
    port = 12345 # set port

    s.connect((host, port))
    print(s.recv(1024))
    s.close()

Now we even have to open the terminal, the first terminal performs server.py file:

    $ python server.py

The second terminal performs client.py file:

    $ Python client.py
    Welcome to dev.to!

This is our first and then open a terminal, you will see the following information is output:

    Connection address: ( '192.168.2.64', 62461)

Internet protocols

Here are some important internet protocols:

Agreement	useful function	port number	Python module
HTTP	Web access	80	httplib, urllib, xmlrpclib
NNTP	reading and posting news articles	119	nntplib
FTP	File Transfer	20	ftplib, urllib
SMTP	Send Mail	25	smtplib
POP3	Incoming mail	110	poplib
IMAP4	get the message	143	imaplib
Telnet	Command Line	23	telnetlib
Gopher	FIND	70	gopherlib, urllib

Go language data types

toebes618 — Tue, 03 Mar 2020 00:30:20 +0000

In the Go programming language, data types are used to declare functions and variables.

A variable can be a boolean (True/False), a number (1,2,3), text etc. The Go language needs to know what kinds of data you want to store.

There are several types of data by category:

No.	Type and Description
1	Boolean Boolean values can only be constants true or false. A simple example: var b bool = true.
2	numeric type Int integer and floating-point float, Go language support integer and floating point numbers, and native support complex, wherein the position calculation using complement.
3	string type: Character string is a string of fixed length connecting the character sequence. Go strings are connected by a single byte. Go byte language string using UTF-8 encoding of a Unicode text identifier.
4	derived types: pointer, an array, struct, Union, function, slice, interface, map, channel

numeric type

Go is also based on the type of architecture, such as: int, uint and uintptr.

No.	Type and Description
1	uint8 Unsigned 8-bit integers (0 to 255)
2	uint16 Unsigned 16-bit integers (0 to 65535)
3	uint32 Unsigned 32-bit integers (0 to 4,294,967,295)
4	uint64 64-bit unsigned integer (0-18446744073709551615)
5	int8 Signed 8-bit integer (-128 to 127)
6	int16 Signed 16-bit integer (-32768 to 32767)
7	int32 Signed 32-bit integer (-2147483648 to 2147483647)
8	int64 Signed 64-bit integer (-9223372036854775808 to 9223372036854775807)

Float:

No.	Type and Description
1	float32 IEEE-754 32-bit floating point number
2	float64 IEEE-754 64-bit floating point number
3	complex64 32-bit real and imaginary
4	complex128 64-bit real and imaginary

other numeric types

Here are more of the other types of numbers:

No.	Type and Description
1	byte Similar uint8
2	rune Similar int32
3	uint 32 or 64
4	int And the same size as uint
5	uintptr Unsigned int, for storing a pointer

Go language constants

toebes618 — Mon, 02 Mar 2020 22:42:36 +0000

In Go programming, a constant is a simple constant value of the identifier, the program runs, the amount can not be modified.

Data type constant may be only boolean, numeric (integer, floating point and complex) and string.

Constant definition format:

    const identifier [type] = value

It can omit the type specifier [type], because the compiler can infer the type based on the value of the variable.

Explicit typing: const b string = "abc"
Implicit type definition: const b = "abc"

More of the same type of statement can be abbreviated as:

    const c_name1, c_name2 = value1, value2

The following examples demonstrate the application of constants:

package main

import "fmt"

func main () {
   const LENGTH int = 10
   const WIDTH int = 5
   var area int
   const a, b, c = 1, false, "str" // multiple assignment
   area = LENGTH * WIDTH
   fmt.Printf( "area:% d", area)
   println()
   println(a, b, c)
}

Examples of the above operating results are:

area: 50
1 false str

Constants can also be used to enumerate:

    const (
        Unknown = 0
        Female = 1
        Male = 2
    )

Numbers 0, 1 and 2, respectively, on behalf of unknown gender, women and men.

Constants can use len(), cap(), unsafe.Sizeof().

package main

import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main() {
    println(a, b, c)
}

Examples of the above operating results are:

abc 3 16

Django template

toebes618 — Mon, 02 Mar 2020 21:37:36 +0000

This is a continuation of the Python Django web app article.

In the previous article, we used django.http.httpResponse() to output the word "Hello World!". This way of mixing data with views is not in line with Django's MVC thinking.

If you want, you can put your Python app online

Templates

In the project in our previous article, we create the templates directory under the HelloWorld directory and create the hello.html file, the entire directory structure is as follows:

HelloWorld/
|-- HelloWorld
|   |-- __init__.py
|   |-- __init__.pyc
|   |-- settings.py
|   |-- settings.pyc
|   |-- urls.py
|   |-- urls.pyc
|   |-- view.py
|   |-- view.pyc
|   |-- wsgi.py
|   `-- wsgi.pyc
|-- manage.py
`-- templates
    `-- hello.html

Hello.html The file code is as follows:

<h1>{{ hello }}</h1>

We know from the template that the variable uses double parentheses.

Next we need to explain the path to the template file to Django, modify HelloWorld/sets.py, modify the DIRS in TEMPLATES to be BASE_DIR /templates, as follows:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR+"/templates",],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

We now modify the view.py to add a new object to submit data to the template:

#-*- coding: utf-8 -*-

#from django.http import HttpResponse
from django.shortcuts import render

def hello(request):
    context = {}
    context['hello'] = 'Hello World!'
    return render(request, 'hello.html', context)

As you can see, here we replaced the httpResponse we used. The render also uses a dictionary context as an argument.

The key value of the element in the context dictionary, "hello", corresponds to the variable in the template.

Visit again at /hello/ to see the page:

This allows us to use templates to output data, so that the data can be separated from the view.

Next, we'll take a look at the syntax rules that are commonly used in the template.

Django template language

if/else label

Like in the Python programming language, tempates allow for use of if statements. The basic syntax format is as follows:

{% if condition %}
     ... display
{% endif %}

Or:

{% if condition1 %}
   ... display 1
{% elif condiiton2 %}
   ... display 2
{% else %}
   ... display 3
{% endif %}

This determines what the output is based on the conditions. if/else supports nesting.

The {% if %} tag accepts the and, or and not keywords to judge multiple variables, or reverse the variables (not), for example:

{% if athlete_list and coach_list %}
     ....
{% endif %}

for tags

The {% for %} allows us to iterate on a sequence.
This is similar to Python's for loop.

<ul>
{% for athlete in athlete_list %}
    <li>{{ athlete.name }}</li>
{% endfor %}
</ul>

Add a reversed to tag so that the list is reverse-iterated:

{% for athlete in athlete_list reversed %}
...
{% endfor %}

You can nest with the hashtag :

{% for athlete in athlete_list %}
    <h1>{{ athlete.name }}</h1>
    <ul>
    {% for sport in athlete.sports_played %}
        <li>{{ sport }}</li>
    {% endfor %}
    </ul>
{% endfor %}

ifequal/ifnotequal

When they are equal, the {% ifequal %} label displays all values:

{% ifequal user currentuser %}
    <h1>Welcome!</h1>
{% endifequal %}

Similar to the if-statement, the {% ifequal %} and {% else %} hashtag can be used.

{% ifequal section 'sitenews' %}
    <h1>Site News</h1>
{% else %}
    <h1>No News Here</h1>
{% endifequal %}

include label

The hashtag allows the content of other templates to be included in the template.

Both examples contain the nav.html template:

{% include "nav.html" %}

Template inheritance

Templates can be reused in an inherited manner.

Let's start by creating a base.html file in the templates directory for the previous project, coded like this:

<html>
  <head>
    <title>Hello World!</title>
  </head>

  <body>
    <h1>Hello World!</h1>
    {% block mainbody %}
       <p>original</p>
    {% endblock %}
  </body>
</html>

In the above code, the block tag, called mainbody, is the part that can be replaced.

All the tags of the {% block %} tells the template engine that the subtemplate can overload these parts.

Hello.html inherits base.html and replaces specific block, hello.html the modified code as follows:

{% extends "base.html" %}

{% block mainbody %}
<p>base.html</p>
{% endblock %}

The first line of code explains that hello.html inherits the base.html file. Then the mainbody block is defined.

Sorted() with Python

toebes618 — Mon, 02 Mar 2020 14:41:28 +0000

You can use Python sorted() function to do sort operation objects. The method sort differs from the method sorted: sort() method is applied on the list, sorted() return a new sorted list from the items in iterable.

The sort() method sorts the already existing list, no return value. The sorted method returns a new list, rather than operations carried out in the original list.

It returns a new sorted list from the items in iterable.

sorted example

The following example demonstrates the use of sorted:

>>> a = [5,7,6,3,4,1,2]
>>> b = sorted(a)
>>> a
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
>>>

To do an ascending sort call the sorted() function. It returns a new sorted list:

>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]

This is different than sort, which uses an existing list.

>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]

Django create first project

toebes618 — Sun, 01 Mar 2020 21:33:15 +0000

Django is a Python module for web development.

If you want to make web apps with Python, you can choose the Django module. It comes with many things like a model-template-view architecture and many tools.

In this article we'll cover Django management tools and how to use Django to create a project.

Before playing with Django, you should learn Python

Django Management Tools

You can install the Django framework on your computer, but you can just as easy get your Python Django app online.

After you install Django, you should now have the management tools available django-admin.py. We can use django-admin.py to create a project.

We can look at the introduction of the django-admin.py command:

[user@linux ~]# django-admin.py
Usage: django-admin.py subcommand [options] [args]

Options:
  -v VERBOSITY, --verbosity=VERBOSITY
                        Verbosity level; 0=minimal output, 1=normal output,
                        2=verbose output, 3=very verbose output
  --settings=SETTINGS   The Python path to a settings module, e.g.
                        "myproject.settings.main". If this isn't provided, the
                        DJANGO_SETTINGS_MODULE environment variable will be
                        used.
  --pythonpath=PYTHONPATH
                        A directory to add to the Python path, e.g.
                        "/home/djangoprojects/myproject".
  --traceback           Raise on exception
  --version             show program's version number and exit
  -h, --help            show this help message and exit

Type 'django-admin.py help <subcommand>' for help on a specific subcommand.

Available subcommands:

[django]
    check
    cleanup
    compilemessages
    createcachetable

Create your first project

Use django-admin.py to create helloWorld projects:

django-admin.py startproject HelloWorld

Once the creation is complete, we can view the directory structure of the next project:

[user@linux ~]# cd HelloWorld/
[user@linux HelloWorld]# tree
.
|-- HelloWorld
|   |-- __init__.py
|   |-- settings.py
|   |-- urls.py
|   `-- wsgi.py
`-- manage.py

Catalog description:

HelloWorld: Containers for the project.
manage.py: A practical command-line tool that lets you interact with the Django project in a variety of ways.
HelloWorld/init.py: An empty file that tells Python that the directory is a Python package.
HelloWorld/sets.py: Settings/configuration of the Django project.
HelloWorld/urls.py: URL statement for the Django project; A Django-driven website.
HelloWorld/wsgi.py: An entrance to a WSGI-compatible Web server to run your project.

Next, we go into the HelloWorld directory and enter the following command to start the server:

python manage.py runserver 0.0.0.0:8000

0.0.0.0 allows other computers to connect to the development server, with 8000 as the port number. If not, the port number defaults to 8000.

Enter your server's ip and port number in the browser, and if it starts normally, the output is as follows:

View and URL configuration
Create a new view.py file in the HelloWorld directory under the helloWorld directory you created earlier and enter the code:

from django.http import HttpResponse

def hello(request):
 return HttpResponse("Hello world ! ")

Next, bind the URL with the view function. Open the urls.py file, delete the original code, copy and paste the following code into the urls.py file (Django 1.6 Use "from django.conf.urls.defaults import"):

from django.conf.urls import url
from . import view

urlpatterns = [
    url(r'^$', view.hello),
]

The entire directory structure is as follows:

$ tree
.
|-- HelloWorld
|   |-- __init__.py
|   |-- __init__.pyc
|   |-- settings.py
|   |-- settings.pyc
|   |-- urls.py              
|   |-- urls.pyc
|   |-- view.py              
|   |-- view.pyc             
|   |-- wsgi.py
|   `-- wsgi.pyc
`-- manage.py

When you're done, start the Django development server and open the browser with a browser access and access:

If you want, you can put your app online

Go arrays examples

toebes618 — Sun, 01 Mar 2020 20:35:07 +0000

Go language provides an array type of data structure.

It is a fixed-length set of data items having the same unique data type, this may be any type of primitive types such as string, integer or another data type.

Array element can be read by the index (position) (or modified), the index starts from 0, the first element index is 0, the second index 1, and so on.

declaration of an array

The Go language array requires that you specify the element type and number of elements, the syntax is as follows:

    var variable_name[SIZE] variable_type

Defined above is one-dimensional array. And the length of the array must be an integer greater than 0. The following example defines the length of the array 10 balance type float32:

    var balance[10] float32

initialize an array

The following illustrates the array initialization:

    var balance = [5] float32 {1000.0, 2.0, 3.4, 7.0, 50.0}

Initializes the number of elements in the array.

If the array size is not provided, Go will set the size of the array according to the number of elements:

     var balance = [] float32 {1000.0, 2.0, 3.4, 7.0, 50.0}

This example is the same as above, although the size of the array is not provided.

     balance[4] = 50.0

The above examples read the fifth element. Array element can be read by the index (position) (or modify), the index starts from 0, the first element index is 0, the second index 1, and so on.

access array elements

Array element can be read by the index (position). The format of the array name in square brackets, brackets in the value of the index. E.g:

    float32 salary = balance[9]

The following illustrates the full array of operations (statement, assignment, access) examples:

package main

import "fmt"

func main () {
    var n[10] int /* n is a length of the array 10 */
    var i, j int

    /* Initialize an array element n */
    for i = 0; i <10; i ++ {
        n[i] = i + 100 /* set elements i + 100 */
    }

    /* Output value of each array element */
    for j = 0; j <10; j ++ {
        fmt.Printf( "Element [%d] = %d \n", j, n[j])
    }
}

Examples of the implementation of the above results are as follows:

    Element [0] = 100
    Element [1] = 101
    Element [2] = 102
    Element [3] = 103
    Element [4] = 104
    Element [5] = 105
    Element [6] = 106
    Element [7] = 107
    Element [8] = 108
    Element [9] = 109

Content	Description
Multidimensional array	Go language support multidimensional arrays, multidimensional arrays are the simplest two-dimensional array
Pass an array to function	You can pass an array parameter as a function

Go basic syntax

toebes618 — Sun, 01 Mar 2020 19:22:40 +0000

You will learn about the basic grammar of the Go programming language (sometimes named Golang).

The syntax of Go is similar to C, but with memory safety, garbage collection, structural typing, and CSP-style concurrency

Go statements

Go program statements may contain keywords, identifiers, constants, a string, a symbol etc. An example Go statement:

    fmt.Println ( "Hello, World!")

If we split it, you'd see

    1. fmt
    2. .
    3. Println
    4. (
    5. "Hello, World!"
    6.)

The package "fmt" (1), the Print function (3), the parameter (5)
run the "Hello world" app

You can run the hello world app using the Go compiler.

line separator

In the Go program, a statement ends automatically. Each statement is not like the other C/C++ family of languages with a semicolon ; at the end, because this is done automatically by the Go compiler.

If you intend to write multiple statements on the same line, they must be used; but in the actual development, we do not encourage this practice.

The following are two statements:

    fmt.Println ( "Hello, World!")
    fmt.Println ( "dev.to")

comments

Comments are not compiled, each line of code should have a relevant comment.

Single-line comments are the most common form of comments, you can use single-line comments begin with // anywhere.

Multi-line comments, also called block comments at the beginning have been to /* and end with */. Such as:

    // a single line comment
    / *
     Author toebes
     I am a multi-line comments
     * /

Identifier

An Identifier is used to name variables, like the type of program entities.

An identifier is actually a letter or a plurality of (A ~ Z and a ~ z) numbers (0 to 9), _ underlined sequence consisting of, but the first character must be a letter.

The following are valid identifiers:

move_name
a_123
myname50
_temp
j
a23b9
retVal

The following are invalid identifiers:

1ab (start with a number)
case (keyword Go language)
A + b (the operator is not allowed)

keyword

Go has 25 keywords or reserved words, that you cannot use for variable names:

break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

In addition to the above description of these keywords, Go language there are 36 predefined identifiers:

append	bool	byte	cap	close	complex	complex64	complex128	uint16
copy	false	float32	float64	imag	int	int8	int16	uint32
int32	int64	iota	len	make	new	nil	panic	uint64
print	println	real	recover	string	true	uint	uint8	uintptr

Program typically consists of the keyword, constants, variables, operators, type, and functions.

Delimiters can be used: parentheses (), brackets [] and braces {}.

The program may use these punctuation marks: ,;: and .

Go Language spaces

Go declaration of variables in the language must be separated by a space, such as:

    var age int;

Statement to make appropriate use of the space program look easy to read.

No spaces:

    fruit=apples+oranges;

Include spaces between variables and operators, the program looks more beautiful, such as:

    fruit = apples + oranges;

DEV Community: toebes618

Django model

Database configuration

Defining a model

Database operations

Add data

Get data

Update data

Delete data

What is Go?

First Go program

Python Network Programming

Simple example

Server

Client

Internet protocols

Go language data types

numeric type

other numeric types

Go language constants

Django template

Templates

Django template language

if/else label

for tags

ifequal/ifnotequal

include label

Template inheritance

Sorted() with Python

sorted example

Django create first project

Django Management Tools

Create your first project

Go arrays examples

declaration of an array

initialize an array

access array elements

more content

Go basic syntax

Go statements

line separator

comments

Identifier

keyword

Go Language spaces