Pythonista nous dit "C'est un étrange langage Go"

VISITES Calendrier de l'Avent a finalement épuisé une semaine.

Avec le recul, des articles dans un très large éventail de domaines ont été écrits, et même les gens de l'entreprise étaient souvent surpris de dire: «Cette personne avait ce type de technologie».

Pour moi, c'est l'article de clôture du calendrier de l'Avent 2019!

TL; DR

Certains de nos produits implémentent des serveurs API en ** Go language **.

Je touche Python depuis longtemps, mais j'écris le langage Go depuis environ un mois et demi, mais je vais écrire un article sur ** la différence entre le langage Go et Python ** que j'ai découvert dans mon travail.

Titré

** Pythonista nous dit "C'est un étrange langage de Go" **

Pour le moment, j'ai fait le titre d'un certain programme ~~ Park t (ry ~~ respecté et en ai fait un titre accrocheur (quoi)

Le public cible est défini comme suit.

Je l'écris pour que vous puissiez le lire si vous connaissez la grammaire de Python même si vous n'êtes pas familier avec le langage Go.

Je voudrais couvrir tout, des différences de niveau de grammaire aux caractéristiques linguistiques efficaces au niveau de l'entreprise.

Tout l'article ressemble à ** Go favor **, mais c'est à cause de mon amour pour Python!

Pourquoi Python and Go? Ce serait complètement différent!

Vous avez raison, c'est une langue différente.

Premièrement, Python est un ** langage à typage dynamique et un langage qui s'exécute sur l'interpréteur **, tandis que Go est un ** langage de compilation de langage à typage statique **.

Il semble erroné de comparer cela seul.

** Je pense que ce serait intéressant de le comparer avec une telle différence **, et j'ai pensé que cela pourrait valoir la peine d'essayer d'écrire un article, ce qui était une grande motivation pour écrire un article.

Bien qu'il s'agisse de langages complètement différents, le grand point commun entre Python et Go est que ** les deux langages sont conçus pour être hautement lisibles **.

Il existe différents langages de programmation, mais j'ai un mystérieux sentiment divers que les langages qui sont hautement lisibles et maintenables (en raison de la sélection naturelle) resteront.

Après tout, tout le monde aime le code facile à lire!

Différence entre Python et Go

L'histoire est complètement différente!

Histoire de Python

La naissance de Python est étonnamment ancienne, avec la première version (** Python 0.90 **) de Guido Van Rossum en ** 1991 **. Il est bien connu que le nom "Python" vient de l'émission de télévision de la BBC ** Monty Python's Flying Circus ** (je ne l'ai pas encore vu).

Selon History of Python, Van Rossam semble être un grand fan de la série, courte et mystérieuse pour le langage inventé qui n'avait pas de nom à l'époque. Il semble qu'il porte ce nom parce que je voulais lui donner un autre nom.

Il semble qu'au début c'était ** un développement de passe-temps que je suis allé tuer le temps pour Noël **. C'est vraiment intéressant de rêver qu'une langue créée en tuant le temps sera utilisée partout dans le monde.

** Python 2.0 ** est sorti en 2000 et est devenu un langage majeur (Python --Wikipedia. % B4% E5% 8F% B2).

La grande transition de Python 2.x à Python 3.x qui perd la compatibilité descendante semble maintenant un peu dépassée, mais maintenant ** Python 3.8 ** a été publié ([Python 3.8]. Nouvelles fonctionnalités (résumé)](https://qiita.com/ksato9700/items/3846e8db573a07c71c33)).

image.png (Cité de History of Python)

Python Pensée-Zen de Python

Tapez ʻimport this` sur l'interpréteur Python et vous verrez ** Zen of Python ** en anglais! )

$ 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!

Pour ceux qui ne sont pas bons en anglais, The Zen of Python est utile.

Histoire de Go

Contrairement à Python, qui a commencé avec le développement de loisirs personnels, Go est né de la plus grande entreprise du monde ** Google **. Il a été conçu par les ingénieurs de Google Robert Griesemer, Rob Pike et Ken Thompson dans le cadre d'un projet expérimental visant à développer une nouvelle programmation ([Go --en.wikipedia.org](https: // en). .wikipedia.org / wiki / Go_ (langage_de_programmation))).

** La conception a commencé en 2007 et Go1.0 vient de sortir en 2012 **, qui est une brève histoire des ** nouveaux arrivants ** dans le monde des langages de programmation.

Go est open source, donc tout le monde peut lire le code.

$ git clone https://github.com/golang/go.git #(Remarque!) Il y a environ 200 Mo
$ git log --reverse

Si vous faites ce qui précède, vous pouvez voir les commits vers 2008. (Au fait, le premier commit était une spécification.)

L'un des trois, Rob Pike, peut lire une diapositive PDF du colloque inédit de 2010 sur les systèmes informatiques de Stanford EE ([Another Go at Language Design](https: :). //web.stanford.edu/class/ee380/Abstracts/100428-pike-stanford.pdf)).

Si vous regardez ce PDF, il a un contenu assez intéressant, mais en gros, il résout les problèmes de Java et C ++ (code redondant, temps de compilation lent, gros binaire, etc.) Il semble que Go a été conçu pour faire **.

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.

Surtout lors de la traduction de cette partie,

** L'objectif de Go est de connecter les deux suivants. ** **

C'est une belle histoire, mais Go est le langage qui essaie vraiment d'y arriver.

Le PDF mentionne également les fonctionnalités de Go ** qui résolvent des problèmes dans d'autres langues **.

L'interprétation de la partie orthogonalité est basée sur Orthogonality in Go. Est-ce la raison pour laquelle les packages standard sont étendus et divisés de manière facile à comprendre?

Aller sur la voie de la pensée

Les manières de Go sont résumées et sont collectivement appelées «Go Way».

Effective Go

"Quelle est la méthode ..."

Beaucoup de gens peuvent être curieux à ce sujet, mais il est souvent gâché en suivant une manière qui semble étrange au début.

[Qu'est-ce que "Go language-ness"? La bonté de comprendre la philosophie de Simplicity et de poursuivre le développement le long de Go Way](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)

Il est recommandé car l'explication de ** Go Way ** est écrite en détail.

La grammaire est complètement différente!

Python et Go sont des langages de programmation, il est donc facile de les voir dans le code.

Python "Bonjour le monde"

hello.py


print('Hello, World')

$ python hello.py
Hello, World

Ou

$ 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

Allez "Hello, World"

main.go


package main

import "fmt"

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

$ go run main.go
Hello, World

.. .. .. Hmm.

Comme prévu, il est difficile de faire la différence, alors implémentons-le un peu plus pratiquement.

Essayez d'implémenter la même fonctionnalité dans Python et Go

Implémentons des programmeurs ennuyeux en Python et Go pour diffuser respectivement leur langage de programmation préféré à d'autres programmeurs.

Comme spécification,

Python

Commençons par créer une classe Programmer en Python.

Tout d'abord, la mise en œuvre minimale.

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)

Vous pouvez définir getter et setter en utilisant le décorateur @ property. Vous pouvez maintenant implémenter des variables privées (comme).

En ce qui concerne name, je n'ai pas implémenté setter, donc il ne sera pas accessible de l'extérieur (bien que cela puisse être fait).

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)

En Python, préfixez tout ce que vous voulez en tant que variable privée avec __.

Allez "struct"

J'ai essayé d'implémenter la même fonction dans Go que celle implémentée en Python. J'essaie de le rendre le plus proche possible du code que j'écris en entreprise.

main.go


package main

type Language string

//Le programmeur est l'interface du programmeur (variable globale)
type Programmer interface {
	TeachFavoriteLanguage(target Programmer) error
	SetFavoriteLanguage(lang Language) error
	FavoriteLanguage() Language
}

//le programmeur implémente l'interface du programmeur(Ne peut être référencé qu'à partir du package)
type programmer struct {
	Programmer
	name             string
	favoriteLanguage Language
}

//NewProgrammer renvoie un nouveau programmeur
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
}

//Implémentation de TeachFavoriteLanguage
func (p *programmer) TeachFavoriteLanguage(target Programmer) error {
	err := target.SetFavoriteLanguage(p.FavoriteLanguage())
	if err != nil {
		return err
	}
	return nil
}

//Dans la fonction principale, vous ne pouvez communiquer qu'avec l'interface de programmation
func main() {
	pythonista := NewProgrammer("zawawahoge", Language("Python"))
	go_lover := NewProgrammer("go_lover", Language("Go"))

	err := pythonista.TeachFavoriteLanguage(go_lover)

	if err != nil {
		panic("Une erreur s'est produite pendant le travail missionnaire")
	}
}

À première vue, vous pouvez voir que la quantité de code est extrêmement supérieure à celle de Python.

** Pourquoi augmente-t-il autant! ?? !! ?? !! ?? ** **

Si vous augmentez les fonctionnalités qui sont différentes de Python,

Dans Go, si le premier caractère d'une variable est ** supérieur, ce sera une variable globale **, et s'il est ** inférieur, ce sera une variable de package (visible uniquement dans le même package) **.

La quantité de code lui-même est plus grande que celle de Python, mais ** chacun a une signification claire et il n'y a pas de gaspillage **.

Les deux sont lisibles, mais les fonctionnalités sont complètement différentes!

Lisibilité Python

En raison de l'indentation forcée, la spécification du langage est telle qu'il ne peut pas s'agir de code illisible tel qu'un fichier compressé .js. Les nouveaux utilisateurs de Python disent souvent que l'indentation est désagréable, mais en fait, cela facilite la compréhension de la portée en un coup d'œil **.

De plus, la quantité de code est extrêmement inférieure à celle d'un langage de compilation normal. La raison pour laquelle Python s'est répandu jusqu'à présent dans le calcul scientifique et technologique est probablement parce qu'il a la particularité de pouvoir envelopper diverses bibliothèques avec une interface facile à comprendre.

Cependant, comme il s'agit d'un langage typé dynamiquement, il présente l'inconvénient qu'il est difficile d'utiliser la complétion IDE, etc., et il est difficile d'empêcher que le contenu des objets soit détruit à l'avance en raison des spécifications du langage, donc cela dépendait fortement de la compétence de l'implémenteur. Il peut être appelé un langage (notamment lors de la création d'une bibliothèque).

Aller lisibilité

Python est en fait extrêmement flexible, il arrive donc souvent que l'implémentation diffère considérablement d'une personne à l'autre. Avec Go, en raison des caractéristiques de la langue, la méthode de mise en œuvre est déterminée dans une certaine mesure à cette fin, donc ** le code sera similaire quelle que soit la personne qui l'a écrit **.

Grâce à cela, même si vous développez avec plusieurs développeurs, il est peu probable que vous ne compreniez pas du tout l'implémentation.

** Bien que ce soit un langage difficile à apprécier, je pense que le code sera indépendant de l'implémenteur car l'implémentation nécessaire et suffisante est naturellement requise **.

La gestion des erreurs est complètement différente!

Gestion des erreurs Python try ~ except

En Python, vous utilisez la syntaxe try ~ except.

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

La gestion des erreurs du système «try ~ catch» a une surcharge importante pour la détection des erreurs, et les performances peuvent se détériorer même si aucune erreur ne se produit. Puisque la surcharge est lourde si vous entourez tout dans try, écrivez la gestion des erreurs en n'insérant que la partie où une erreur est susceptible de se produire dans try. Alors, que faites-vous lorsqu'une erreur se produit sans "try"? Ce sera une histoire.

Aller à la gestion des erreurs

Contrairement à d'autres langages, Go ne gère pas les erreurs avec try ~ catch ou try ~ except, et détermine le succès ou l'erreur en fonction de la valeur de retour de type ʻerror`.

La gestion des erreurs suivante apparaît fréquemment dans le code Go.

Si vous ne le connaissez pas, c'est probablement ** désagréable ** (premier auteur).

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)
}

Tout comme Go, si vous vérifiez simplement si ʻerrestnil ( None` en Python), vous pouvez détecter l'erreur, donc la surcharge est très faible et la dégradation des performances pour la détection d'erreur est réduite. Presque pas besoin.

L'inconvénient est que vous allez écrire la gestion des erreurs dans presque tous les morceaux de code, donc c'est ** en quelque sorte ennuyeux ** jusqu'à ce que vous y soyez habitué. Cependant, au moment où vous vous y habituerez, vous serez plus rassuré de pouvoir gérer tout le code avec des erreurs! ** **

Résumé

** Pythonista nous dit "C'est un étrange langage de Go" ** Comment était-ce?

Contrairement au titre, je suis désolé pour ** Go favor **.

En termes d'articles, je voulais aussi écrire des items de test, mais j'étais épuisé.

En écrivant cet article, j'ai décidé d'étudier à la fois Python et Go, mais grâce à cela, j'ai appris ** beaucoup **, donc j'ai pensé qu'il était bon de le choisir comme sujet.

Ce sera encourageant si vous aimez quelqu'un qui a quelque chose à transmettre.

Merci beaucoup.

URL de référence

Recommended Posts

Pythonista nous dit "C'est un étrange langage Go"
[Golang] Go les bases de la langue Qu'est-ce que Goroutine?