Pythonista sagt uns "Das ist eine seltsame Go-Sprache"

BESUCHT Adventskalender hat endlich keine Woche mehr.

Rückblickend wurden Artikel in einer Vielzahl von Bereichen geschrieben, und selbst die Mitarbeiter des Unternehmens waren oft überrascht zu sagen: "Diese Person hatte diese Art von Technologie."

Für mich ist dies der Abschlussartikel für den Adventskalender 2019!

TL; DR

Einige unserer Produkte implementieren API-Server in der Sprache ** Go **.

Ich habe Python schon lange berührt, aber ich schreibe die Go-Sprache seit ungefähr anderthalb Monaten, aber ich werde einen Artikel über den Unterschied zwischen der Go-Sprache und Python schreiben, den ich in meiner Arbeit herausgefunden habe.

Betitelt

** Pythonista sagt uns "Das ist eine seltsame Go-Sprache" **

Vorerst habe ich den Titel eines bestimmten Programms gemacht ~~ Park t (ry ~~ respektiert und es zu einem eingängigen Titel gemacht (was)

Die Zielgruppe wird wie folgt festgelegt.

Ich schreibe es, damit Sie es lesen können, wenn Sie die Grammatik von Python kennen, auch wenn Sie mit der Go-Sprache nicht vertraut sind.

Ich möchte alles abdecken, von Unterschieden in der Grammatikstufe bis zu Sprachmerkmalen, die auf geschäftlicher Ebene wirksam sind.

Der ganze Artikel fühlt sich an wie ** Go favor **, aber es liegt an meiner Liebe zu Python!

Warum Python und Go? Es wäre ganz anders!

Du hast recht, es ist eine andere Sprache.

Erstens ist Python eine ** dynamisch typisierte Sprache und eine Sprache, die auf dem Interpreter ausgeführt wird **, während Go eine ** statisch typisierte Sprachkompilierungssprache ** ist.

Es scheint falsch, dies allein zu vergleichen.

** Ich denke, es wäre interessant, es mit einem solchen Unterschied zu vergleichen **, und ich dachte, es könnte sich lohnen, einen Artikel zu schreiben, was eine große Motivation für das Schreiben eines Artikels war.

Obwohl es sich um völlig unterschiedliche Sprachen handelt, haben Python und Go gemeinsam, dass ** beide Sprachen gut lesbar sind **.

Es gibt verschiedene Programmiersprachen, aber ich habe das mysteriöse Gefühl, dass die Sprachen, die (aufgrund natürlicher Selektion) gut lesbar und wartbar sind, erhalten bleiben.

Sie alle lieben auch einfach zu lesenden Code!

Unterschied zwischen Python und Go

Die Geschichte ist ganz anders!

Geschichte von Python

Die Geburt von Python ist überraschend alt, mit der ersten Veröffentlichung (** Python 0.90 **) von Guido Van Rossum in ** 1991 **. Es ist bekannt, dass der Name "Python" von einer BBC-TV-Show namens ** Monty Pythons Flying Circus ** stammt (ich habe ihn noch nicht gesehen).

Laut History of Python scheint Van Rossam ein großer Fan der Show zu sein, kurz und mysteriös für die erfundene Sprache, die zu diesem Zeitpunkt keinen Namen hatte. Es scheint, dass es diesen Namen bekam, weil ich ihm einen anderen Namen geben wollte.

Es scheint, dass es zunächst eine Hobbyentwicklung war, die ich mir zu Weihnachten Zeit genommen habe. Es ist wirklich interessant zu träumen, dass eine Sprache, die durch das Töten der Zeit geschaffen wurde, auf der ganzen Welt verwendet wird.

** Python 2.0 ** wurde im Jahr 2000 veröffentlicht und wurde als Hauptsprache bekannt (Python --Wikipedia. % B4% E5% 8F% B2).

Der große Übergang von Python 2.x zu Python 3.x, der die Abwärtskompatibilität verliert, scheint nun etwas vorbei zu sein, aber jetzt wurde ** Python 3.8 ** veröffentlicht ([Python 3.8]). Neue Funktionen (Zusammenfassung)](https://qiita.com/ksato9700/items/3846e8db573a07c71c33)).

image.png (Zitiert aus History of Python)

Python Thought-Zen von Python

Geben Sie "import this" in den Python-Interpreter ein und Sie sehen ** Zen of Python ** auf Englisch! )

$ python
Python 3.8.0 (default, Oct 31 2019, 16:56:00)
[Clang 11.0.0 (clang-1100.0.33.8)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Für diejenigen, die nicht gut Englisch können, ist The Zen of Python hilfreich.

Geschichte von Go

Im Gegensatz zu Python, das mit der persönlichen Hobbyentwicklung begann, wurde Go von der weltweit größten Firma ** Google ** geboren. Es wurde von den Google-Ingenieuren Robert Griesemer, Rob Pike und Ken Thompson in einem experimentellen Projekt zur Entwicklung neuer Programme entwickelt ([Go --en.wikipedia.org](https: // en). .wikipedia.org / wiki / Go_ (Programmiersprache))).

** Design begann 2007 und Go1.0 wurde erst 2012 veröffentlicht **, was eine kurze Geschichte von ** Newcomern ** in der Welt der Programmiersprachen ist.

Go ist Open Source, sodass jeder den Code lesen kann.

$ git clone https://github.com/golang/go.git #(Hinweis!) Es gibt ungefähr 200 MB
$ git log --reverse

Wenn Sie die oben genannten Schritte ausführen, können Sie die Commits um 2008 anzeigen. (Das erste Commit war übrigens eine Spezifikation.)

Einer der drei, Rob Pike, kann ein PDF der unveröffentlichten 2010 Stanford EE Computer Systems Colloquium-Folie ([Another Go at Language Design](https: :)) lesen. //web.stanford.edu/class/ee380/Abstracts/100428-pike-stanford.pdf)).

Wenn Sie sich dieses PDF ansehen, hat es einen recht interessanten Inhalt, aber grob gesagt löst es die Probleme, die Java und C ++ haben (redundanter Code, langsame Kompilierungszeit, große Binärdateien usw.). Es scheint, dass Go dafür entwickelt wurde **.

The Target: Go aims to combine the safety and performance of a statically typed compiled language with the expressiveness and convenience of a dynamically typed interpreted language.

Besonders bei der Übersetzung dieses Teils,

** Go hat sich zum Ziel gesetzt, die folgenden beiden zu verbinden. ** **.

Es ist eine schöne Geschichte, aber Go ist die Sprache, die wirklich versucht, dies zu erreichen.

Das PDF erwähnt auch die ** Funktionen von Go, die Probleme in anderen Sprachen lösen **.

Die Interpretation des Orthogonalitätsteils basiert auf Orthogonalität in Go. Sind die Standardpakete deshalb umfangreich und leicht verständlich unterteilt?

Geh Gedanken-Weg

Die Manieren von Go sind zusammengefasst und werden gemeinsam "Go Way" genannt.

Effective Go

"Was ist die Methode ..."

Viele Leute mögen neugierig sein, aber es wird oft durcheinander gebracht, wenn man einer Art und Weise folgt, die auf den ersten Blick seltsam erscheint.

[Was ist "Go language-ness"? Die Güte, die Philosophie von Simplicity zu verstehen und die Entwicklung auf dem Go Way fortzusetzen](https://employment.en-japan.com/engineerhub/entry/2018/06/19/110000#Go%E8%A8% 80% E8% AA% 9E% E3% 82% 89% E3% 81% 97% E3% 81% 95% E3% 81% A8% E3% 81% AF)

Es wird empfohlen, da die Erklärung von ** Go Way ** sehr detailliert geschrieben ist.

Die Grammatik ist völlig anders!

Sowohl Python als auch Go sind Programmiersprachen, daher ist es einfach, sie im Code zu sehen.

Python "Hallo Welt"

hello.py


print('Hello, World')

$ python hello.py
Hello, World

Oder

$ python
Python 3.8.0 (default, Oct 31 2019, 16:56:00)
[Clang 11.0.0 (clang-1100.0.33.8)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>print('Hello, World')
Hello, World

Go's "Hallo Welt"

main.go


package main

import "fmt"

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

$ go run main.go
Hello, World

.. .. .. Hmm.

Wie erwartet ist es schwierig, den Unterschied zu erkennen, also lassen Sie es uns etwas praktischer implementieren.

Versuchen Sie, dieselbe Funktionalität in Python und Go zu implementieren

Lassen Sie uns nervige Programmierer in Python und Go implementieren, um ihre bevorzugte Programmiersprache auf andere Programmierer zu übertragen.

Als Spezifikation,

Python

Zuerst erstellen wir eine Programmer-Klasse in Python.

Erstens die minimale Implementierung.

main.py


class Programmer:
    def __init__(self, name, favorite_language):
        self.name = name
        self.favorite_language = favorite_language

    def teach_favorite_language(self, prog):
        prog.favorite_language = self.favorite_language


pythonista = Programmer("zawawahoge", "Python")
go_lover = Programmer("foobar", "Go")

pythonista.teach_favorite_language(go_lover)

Sie können Getter und Setter mit dem Dekorator @ property einstellen. Jetzt können Sie private Variablen (wie) implementieren.

In Bezug auf name habe ich den Setter nicht implementiert, daher ist er von außen nicht zugänglich (obwohl dies möglich ist).

main.py


class Programmer:
    def __init__(self, name, favorite_language):
        self.__name = name
        self.__favorite_language = favorite_language
        
    @property
    def name(self):
        return self.__name
   
    @property
    def favorite_language(self):
        return self.__favorite_language
    
    @favorite_language.setter
    def favorite_language(self, favorite_language):
        self.__favorite_language = favorite_language

    def teach_favorite_language(self, prog):
        prog.favorite_language = self.favorite_language


pythonista = Programmer("zawawahoge", "Python")
go_lover = Programmer("go_lover", "Go")

pythonista.teach_favorite_language(go_lover)

Stellen Sie in Python vor allem, was Sie als private Variable verwenden möchten, "__" ein.

Gehen Sie "struct"

Ich habe versucht, dieselbe Funktion in Go zu implementieren, die in Python implementiert wurde. Ich versuche, es so nah wie möglich an den Code zu bringen, den ich im Geschäft schreibe.

main.go


package main

type Language string

//Programmierer ist die Schnittstelle des Programmierers (globale Variable)
type Programmer interface {
	TeachFavoriteLanguage(target Programmer) error
	SetFavoriteLanguage(lang Language) error
	FavoriteLanguage() Language
}

//Programmierer implementiert die Programmiererschnittstelle(Kann nur innerhalb des Pakets referenziert werden)
type programmer struct {
	Programmer
	name             string
	favoriteLanguage Language
}

//NewProgrammer gibt einen neuen Programmierer zurück
func NewProgrammer(name string, lang Language) Programmer {
	return &programmer{
		name:             name,
		favoriteLanguage: lang,
	}
}

// getter
func (p *programmer) FavoriteLanguage() Language {
	return p.favoriteLanguage
}

// setter
func (p *programmer) SetFavoriteLanguage(lang Language) error {
	p.favoriteLanguage = lang
	return nil
}

//Implementierung von TeachFavoriteLanguage
func (p *programmer) TeachFavoriteLanguage(target Programmer) error {
	err := target.SetFavoriteLanguage(p.FavoriteLanguage())
	if err != nil {
		return err
	}
	return nil
}

//Innerhalb der Hauptfunktion können Sie nur mit der Programmierschnittstelle kommunizieren
func main() {
	pythonista := NewProgrammer("zawawahoge", Language("Python"))
	go_lover := NewProgrammer("go_lover", Language("Go"))

	err := pythonista.TeachFavoriteLanguage(go_lover)

	if err != nil {
		panic("Während der Missionsarbeit ist ein Fehler aufgetreten")
	}
}

Auf den ersten Blick sehen Sie, dass die Codemenge überwiegend größer ist als die von Python.

** Warum nimmt es so stark zu! ?? !! ?? !! ?? ** **.

Wenn Sie die Funktionen erhöhen, die sich von Python unterscheiden,

Wenn in Go das erste Zeichen einer Variablen ** oben ist, ist es eine globale Variable **, und wenn es ** niedriger ist, ist es eine Paketvariable (nur innerhalb desselben Pakets sichtbar) **.

Die Menge an Code selbst ist größer als die von Python, aber ** jeder hat eine klare Bedeutung und es gibt keine Verschwendung **.

Beide sind lesbar, aber die Funktionen sind völlig unterschiedlich!

Python-Lesbarkeit

Aufgrund des erzwungenen Einrückens erlaubt die Sprachspezifikation keinen unlesbaren Code wie komprimierte .js-Dateien. Leute, die Python noch nicht kennen, sagen oft, dass die Einrückung unangenehm ist, aber tatsächlich macht es dies einfacher, den Umfang auf einen Blick zu verstehen **.

Darüber hinaus ist die Codemenge überwiegend kleiner als die einer normalen Kompilierungssprache. Der Grund, warum sich Python in der Wissenschafts- und Technologieberechnung bisher verbreitet hat, liegt wahrscheinlich darin, dass es die Möglichkeit bietet, verschiedene Bibliotheken mit einer leicht verständlichen Oberfläche zu versehen.

Da es sich jedoch um eine dynamisch typisierte Sprache handelt, hat sie den Nachteil, dass es schwierig ist, die IDE-Vervollständigung usw. zu verwenden, und es ist schwierig zu verhindern, dass der Inhalt von Objekten aufgrund der Sprachspezifikationen im Voraus zerstört wird, so dass dies stark von den Fähigkeiten des Implementierers abhängt. Es kann als Sprache bezeichnet werden (insbesondere beim Erstellen einer Bibliothek).

Gehen Sie Lesbarkeit

Python ist tatsächlich extrem flexibel, so dass es häufig vorkommt, dass die Implementierung von Person zu Person sehr unterschiedlich ist. Bei Go wird aufgrund der Merkmale der Sprache die Implementierungsmethode zu einem gewissen Grad für den Zweck festgelegt, sodass ** der Code unabhängig von der Person, die ihn geschrieben hat, ähnlich ist **.

Selbst wenn Sie mit mehreren Entwicklern entwickeln, ist es daher unwahrscheinlich, dass Sie die Implementierung überhaupt nicht verstehen.

** Obwohl es schwierig ist, eine Sprache zu genießen, denke ich, dass der Code implementierungsunabhängig sein wird, da die notwendige und ausreichende Implementierung natürlich erforderlich ist **.

Die Fehlerbehandlung ist völlig anders!

Python-Fehlerbehandlung try ~ Except

In Python verwenden Sie die Syntax "try ~ Except".

try:
    do_something()
    res = get_something()
except Exception as e:
    print(f"e={e}, type(e)={type(e)}")

Die Fehlerbehandlung des "try ~ catch" -Systems hat einen großen Aufwand für die Fehlererkennung, und die Leistung kann sich verschlechtern, selbst wenn kein Fehler auftritt. Da der Overhead hoch ist, wenn Sie alles in "try" einschließen, schreiben Sie die Fehlerbehandlung, indem Sie nur den Teil einschließen, in dem wahrscheinlich ein Fehler in "try" auftritt. Was machen Sie dann, wenn ein Fehler ohne "try" auftritt? Es wird eine Geschichte sein.

Gehen Sie zur Fehlerbehandlung

Im Gegensatz zu anderen Sprachen behandelt Go keine Fehler mit "try ~ catch" oder "try ~ außer" und verwendet einen Rückgabewert vom Typ "error", um Erfolg oder Fehler zu bestimmen.

Die folgende Fehlerbehandlung wird häufig im Go-Code angezeigt.

Wenn Sie nicht damit vertraut sind, ist es wahrscheinlich ** unangenehm ** (früher Autor).

err := DoSomething()
if err != nil {
        return errors.Errorf("failed to do something; err=%#v", err)
}

res, err := GetSomething()
if err != nil {
        return errors.Errorf("failed to get something; err %#v", err)
}

Genau wie bei Go können Sie den Fehler erkennen, wenn Sie nur überprüfen, ob "err" "nil" ist ("None" in Python), sodass der Overhead sehr gering ist und der Leistungsabfall bei der Fehlererkennung verringert wird. Fast keine Notwendigkeit.

Der Nachteil ist, dass Sie in fast jedem Code Fehlerbehandlung schreiben, so dass es ** irgendwie nervig ** ist, bis Sie sich daran gewöhnt haben. Wenn Sie sich jedoch daran gewöhnt haben, werden Sie sicherer sein, dass Sie den gesamten Code mit Fehlern behandeln können! ** **.

Zusammenfassung

** Pythonista sagt uns "Das ist eine seltsame Go-Sprache" ** Wie war es?

Im Gegensatz zum Titel tut mir ** Go favor ** leid.

In Bezug auf Artikel wollte ich auch Testartikel schreiben, war aber erschöpft.

Als ich diesen Artikel schrieb, beschloss ich, sowohl Python als auch Go zu untersuchen, aber dank dessen lernte ich ** viel ** und fand es gut, ihn als Thema zu wählen.

Es ist ermutigend, wenn Sie jemanden mögen, der etwas zu vermitteln hat.

Vielen Dank.

Referenz-URL

Recommended Posts

Pythonista sagt uns "Das ist eine seltsame Go-Sprache"
[Golang] Go Sprachgrundlagen Was ist Goroutine?