Dieser Artikel ist ein Artikel am Dienstag, den 24. Dezember von DeNA Adventskalender 2019.
Normalerweise benutze ich hauptsächlich Perl, aber ich habe es zusammengefasst, um Go zu lernen und Python zu überprüfen. Pythons Grammatik ist so einfach, dass ich dachte, es wäre schnell, Go aus dem Unterschied zu lernen. Ich habe vor, so viel wie möglich zu schreiben, aber ich denke, es gibt verschiedene Engpässe. Bitte beachten Sie.
Zunächst einmal, wie man einen Kommentar schreibt. Python kann ursprünglich nicht mehrere Zeilen auskommentieren, aber das Einfügen einer Zeichenfolge in Ihr Programm hat keine Auswirkung, sodass Sie damit mehrzeilige Kommentare schreiben können. Außerdem können mehrzeilige Kommentare als Dokumentationszeichenfolge hinterlassen werden.
Python
#1-zeiliger Kommentar
'''
Mehrzeiliger Kommentar
'''
"""
Mehrzeiliger Kommentar
"""
def func():
"""
Programmkommentar usw.
"""
help(func)
print(func.__doc__)
Go
//1-zeiliger Kommentar
/*
Mehrzeiliger Kommentar
*/
Python ist eine dynamisch typisierte Sprache, sodass Sie den Typ einer Variablen nicht deklarieren müssen.
Python
n = 10
name = "hoge"
#Gemeinsam definieren
x, y, z = 1, 2, 3
a = b = c = 1
Im Fall von Go sollten Sie zuerst auf das erste Zeichen des Variablennamens achten.
Dies gilt auch für Konstanten und Funktionen. Go ist eine statisch typisierte Sprache, es gibt jedoch explizite und implizite Definitionen.
Definieren Sie es als "var [Name der Variablen] [Typ der Variablen]".
Go
var n int
n = 1
//Gemeinsam definieren
var x, y, z int
x, y, z = 1, 2, 3
var (
x, y int
name string
)
x, y, name = 1, 2, "hoge"
//Deklarieren Sie den Typ und weisen Sie gleichzeitig den Wert zu
var n int = 1
Definieren Sie es als "[Variablenname]: = [Wert]" oder "var [Variablenname] = [Wert]". Durch das implizite Zuweisen eines Werts wird der Typ der Variablen abgeleitet.
Go
n := 1
//Der Typ kann auch in der Definition mit var weggelassen werden
var n = 1
//Gemeinsam definieren
x, y, name := 1, 2, "hoge"
var (
x = 1
y = 2
name = "hoge"
)
Python hat keine Schlüsselwörter zum Definieren von Konstanten. Konventionell stehen nur Großbuchstaben und Unterstriche für Konstanten.
Python
PI = 3.14
MAX_NUM = 100
Go verwendet "const", um Konstanten zu definieren. Sie können den Bezeichner "iota" verwenden, um eine Folge von ganzen Zahlen zu generieren. Der Versuch, den Wert einer Konstante zu ändern, führt zu einem Fehler.
Go
const Pi = 3.14
const MaxNum = 100
// ()Gemeinsam definieren in
const (
Pi = 3.14
MaxNum = 100
)
const (
X = iota // 0
Y // 1
Z // 2
)
//Bei Angabe der Startnummer
const (
X = iota + 10 // 10
Y // 11
Z // 12
)
Python-Listen können sehr einfach geschrieben werden. Das Folgende ist die grundlegende Verwendung.
Python
#Definition
numbers = [1, 2, 3]
#Element hinzufügen
numbers.append(6)
numbers.insert(3, 5) # numbers: [1, 2, 3, 5, 6]
#Elementanzahl
len(numbers)
#Element löschen
numbers.remove(3) # numbers: [1, 2, 5, 6]
numbers.pop(1) # numbers: [1, 5, 6]
del numbers[0] # numbers: [5, 6]
#Listen kombinieren
numbers += [3, 4] # numbers: [5, 6, 3, 4]
numbers.extend([1, 2]) # numbers: [5, 6, 3, 4, 1, 2]
#Suche nach Elementen
print(6 in numbers) # True
print(numbers.index(6)) # 1
#Sortieren Sie die Liste
numbers.sort() # numbers: [1, 2, 3, 4, 5, 6]
numbers.sort(reverse=True) # numbers: [6, 5, 4, 3, 2, 1]
Der Array-Typ von Go kann nicht vergrößert oder verkleinert werden. Datenstrukturen wie Python-Listen entsprechen Slices in Go.
Die Funktion "Anhängen" wird häufig für Schneidvorgänge verwendet. Für ** ... siehe [Argument der Funktion mit variabler Länge](Argument mit variabler Länge). ** ** **
Go
//Die Größe des Arrays kann nicht geändert werden
array := [3]int{1, 2, 3}
fmt.Println(array[0]) // 1
fmt.Println(array[1:3]) // [2 3]
//Scheibe
n1 := []int{} // n1: []
n2 := make([]int, 0) // n2: []
numbers := []int{1, 2, 3}
//Element hinzufügen
numbers = append(numbers, 6) // numbers: [1 2 3 6]
numbers = append(numbers[0:3], append([]int{5}, numbers[3:]...)...) // numbers: [1 2 3 5 6]
//Elementanzahl
len(numbers)
//Element löschen
numbers = append(numbers[0:2], numbers[3:]...) // numbers: [1 2 5 6]
numbers = numbers[2:] // numbers: [5 6]
//Sequenzen verbinden
numbers = append(numbers, []int{3, 4, 1, 2}...) // numbers: [5 6 3 4 1 2]
//Suche nach Elementen
//Es gibt kein Äquivalent zum Python-Index, schreiben Sie ihn also selbst
fmt.Println(IndexOf(numbers, 6)) // 1
func IndexOf(s []int, n int) int {
for i, v := range s {
if n == v {
return i
}
}
return -1
}
//Sortieren Sie das Array
//Verwenden Sie das Sortierpaket
sort.Ints(numbers)
fmt.Println(numbers) // [1 2 3 4 5 6]
sort.Sort(sort.Reverse(sort.IntSlice(numbers)))
fmt.Println(numbers) // [6 5 4 3 2 1]
Python verwendet eine Datenstruktur, die als Wörterbuch bezeichnet wird.
Python
#Definition
dic = {'hoge': 1, 'fuga': 2, 'piyo': 3}
list1 = [('hoge', 1), ('fuga', 2), ('piyo', 3)]
dic2 = dict(list1) #Gleich wie dic Wert
dic['hoge']
dic.get('hoge')
#Elemente hinzufügen und entfernen
dic['foo'] = 4
dic.setdefault('bar', 5)
dic.pop('hoge') # {'fuga': 2, 'piyo': 3, 'foo': 4, 'bar': 5}
del dic['fuga'], dic['piyo'] # {'foo': 4, 'bar': 5}
#Elementanzahl
len(dic)
#Bestätigung der Schlüsselexistenz
'foo' in dic
#Schlüssel und Werte abrufen
list(dic.keys()) # ['foo', 'bar']
list(dic.values()) # [4, 5]
for k, v in dic.items():
print(k, v)
Die Go-Karte entspricht dem Python-Wörterbuch. Es ist im folgenden Format definiert.
map [Schlüsseltyp] Elementtyp
Go
//Definition
dic := map[string]int{"hoge": 1, "fuga": 2, "piyo": 3}
dic2 := make(map[string]int)
fmt.Println(dic) // map[fuga:2 hoge:1 piyo:3]
fmt.Println(dic2) // map[]
//Elemente hinzufügen und entfernen
dic["foo"] = 4
delete(dic, "hoge")
fmt.Println(dic) // map[foo:4 fuga:2 piyo:3]
//Elementanzahl
len(dic)
//Bestätigung der Schlüsselexistenz
_, exist := dic["foo"]
fmt.Println(exist) // true
if value, exist := dic["foo"]; exist {
fmt.Println(value) // 4
}
//Schlüssel und Werte abrufen
for k, v := range dic {
fmt.Println(k, v)
}
Python hat keine switch-Anweisung. Verwenden Sie stattdessen "if ... elif ... else". Es gibt auch eine Schreibweise, die als bedingter Ausdruck (ternärer Operator) bezeichnet wird.
6.12. Bedingte Ausdrücke https://docs.python.org/ja/3/reference/expressions.html#conditional-expressions
Logische Operatoren verwenden "und", "oder", "nicht".
Python
x, y = 1, 2
if x > y:
print('x > y')
elif x < y:
print('x < y')
else:
print('x == y')
n = 10
#Bedingter Ausdruck
result = "positive" if n > 0 else "negative or zero"
Es gibt zwei Arten der bedingten Verzweigung in Go, if und switch, und Sie können gültige Variablen nur in diesem Block definieren, indem Sie if mit einer einfachen Anweisung schreiben.
Es gibt keinen ternären Operator, aber Sie können ihn mit map so schreiben.
Der logische Operator ist&&,||,!Verwenden Sie die.
Go
x, y := 1, 2
if x > y {
fmt.Println("x > y")
} else if x < y {
fmt.Println("x < y")
} else {
fmt.Println("x == y")
}
#Wenn mit einem einfachen Satz
if x, y := 1, 2; x > y {
fmt.Println("x > y")
} else if x < y {
fmt.Println("x < y")
} else {
fmt.Println("x == y")
}
#switch-Anweisung
x, y := 1, 2;
switch {
case x > y:
fmt.Println("x > y")
case x < y:
fmt.Println("x < y")
default:
fmt.Println("x == y")
}
n := 10
#Wie man wie ein ternärer Operator schreibt
result := map[bool]string{true: "positive", false: "negative"}[n > 0]
Verwenden Sie für und während für Python-Loops.
Python
sum = 0
for num in range(1, 11):
sum += num
num, sum = 1, 0
while num <= 10:
sum += num
num += 1
#Endlosschleife
num, sum = 1, 0
while True:
sum += num
num += 1
if num > 10:
break
Die einzige Go-Schleife ist für, aber Sie können sie auch wie während steuern.
Go
sum := 0
for num := 0 ; num <= 10 ; num++ {
sum += num
}
// while
num, sum := 1, 0
for num <= 10 {
sum += num
num++
}
//Endlosschleife
num, sum := 1, 0
for {
sum += num
num++
if num > 10 {
break
}
}
Python-Funktionen werden mit def definiert. Die Funktionsdefinition muss geschrieben werden, bevor der Funktionsaufruf ausgeführt wird.
Es gibt die folgenden Verwendungen.
Python
def greet(name="World"):
print("Hello, " + name)
greet()
greet("Alice")
greet(name="Alice")
#Variable Länge variabel
def greet(*names):
for name in names:
print("Hello, " + name)
greet("Alice", "Bob", "Carol")
#Mehrere Rückgabewerte
def cal(a, b):
add = a + b
mul = a * b
return add, mul
add, mul = cal(10, 5)
Go-Funktionen werden mit func definiert.
func [Funktionsname]([Argumentdefinition]) [Rückgabetyp] {[Funktionskörper]}
Es gibt keine Standard- oder Schlüsselwortargumente, sie weisen jedoch die folgenden Merkmale auf:
Argumente variabler Länge für Funktionen sind definiert als "[Argumentname] ... [Argumenttyp]". Wenn Sie ein Slice als Argument mit variabler Länge übergeben, müssen Sie nach der Variablen "..." hinzufügen, um das Slice zu erweitern.
Go
func main() {
add, mul := cal(10, 5)
fmt.Println(add, mul) // 15 50
add, mul = calc(10, 5)
fmt.Println(add, mul) // 15 50
greet("Alice", "Bob", "Carol")
names := []string{"Alice", "Bob", "Carol"}
greet(names...) //Übergeben Sie ein Slice als Argument variabler Länge
testDefer() // BDCA
}
//Grundform
func cal(a int, b int) (int, int) {
add := a + b
mul := a * b
return add, mul
}
//Benannter Rückgabewert
//Wenn die Argumenttypen identisch sind, können Sie sie alle zusammen schreiben
func calc(a, b int) (add int, mul int) {
add = a + b
mul = a * b
return
}
//Funktionen ohne Rückgabewert
//Argument variabler Länge
func greet(names ...string) {
for _, name := range names {
fmt.Println("Hello,", name)
}
}
//Aufgeschobene Ausführung aufschieben
func testDefer() {
defer fmt.Print("A")
fmt.Print("B")
defer fmt.Print("C") //C wird vor A ausgegeben
fmt.Print("D")
}
Python verwendet die Syntax "try-exception", um Ausnahmen abzufangen und zu behandeln.
Python
def doDivision(x, y):
try:
result = x / y
except Exception as e:
result = None
print("except:" + e.args[0])
else: #Am normalen Ende ausführen
print("else")
finally: #Immer beim Verlassen laufen
print("finally")
return result
doDivision(10, 2)
# else
# finally
doDivision(10, 0)
# except:test exception
# finally
Es gibt keinen Ausnahmemechanismus wie "try-without" in Go. Stattdessen wird die Eigenschaft, mehrere Rückgabewerte einer Funktion zurückgeben zu können, verwendet, um einen Fehler zu erkennen, indem als Teil des Rückgabewerts zurückgegeben wird, ob ein Fehler aufgetreten ist ("Fehlerschnittstelle"). Die "Fehlerschnittstelle" ist wie folgt definiert: https://golang.org/pkg/builtin/#error
Gehe zu Fehlerschnittstelle
type error interface {
Error() string
}
Im folgenden Beispiel wird die Funktion "Neu" des Pakets "Fehler" verwendet, um einen "Fehlertyp" zu generieren.
Sie können auch defer verwenden, um das gleiche Verhalten wie Pythons finally zu erzielen.
Go
package main
import (
"fmt"
"errors"
)
func main() {
_, err := doDivision(10, 2)
if (err != nil) {
//Fehlerbehandlung
}
// defer
_, err = doDivision(10, 0)
if (err != nil) {
//Fehlerbehandlung
}
// error
// defer
}
func doDivision(i, j int) (result int, err error) {
defer fmt.Println("defer") //Immer beim Verlassen laufen
if j == 0 {
fmt.Println("error")
err = errors.New("Divided by Zero")
return
}
result = i / j
return
}
Darüber hinaus verfügt Go über einen Fehlerbehandlungsmechanismus namens "Panic / Recovery", den ich hier jedoch weglassen werde.
Das Folgende ist ein Beispiel für eine einfache Python-Klasse.
Python
class Player:
def __init__(self, id, name):
self.id = id
self.name = name
self.__hp = 100
@property
def hp(self):
return self.__hp
def consume_hp(self, num):
self.__hp -= num
player = Player(10001, "Alice")
print(player.hp) # 100
player.consume_hp(10)
print(player.hp) # 90
Go hat keine Syntax, die in Python der Klasse entspricht, verwendet jedoch eine Struktur, die verwandte Variablen in einer ähnlichen Rolle zusammen behandelt. Sie können Methoden für die Struktur definieren. Im Gegensatz zu Funktionen erfordern Methoden den Empfängertyp und seinen Variablennamen. Das folgende Beispiel definiert eine Methode namens "verbrauchenHp" für einen Zeigertyp namens "* Player".
Go
//Struktur des Spielertyps
type Player struct{
ID int
Name string
Hp int
}
//Konstrukteur
func newPlayer(id int, name string) Player {
return Player{ID: id, Name: name, Hp: 100}
}
// *Spielertyp-Methode
func (p *Player) consumeHp(num int) {
p.Hp -= num
}
func main() {
p := newPlayer(10001, "Alice")
fmt.Println(p.Hp) // 100
p.consumeHp(10)
fmt.Println(p.Hp) // 90
}
Abschließend werde ich ein wenig über Multithreading schreiben. Das Folgende ist ein einfaches Beispiel für die Verwendung des Threading-Moduls, um einen Thread zu erzeugen und Daten in einer Warteschlange zu übergeben.
Python
import threading
import time
from queue import Queue
def worker(a, b, q):
time.sleep(1)
result = a + b
q.put(result) #Stellen Sie Elemente in die Warteschlange
print("result:", result)
q = Queue()
thread = threading.Thread(target=worker, args=(2, 3, q))
thread.start()
thread.join()
print("main thread")
result = q.get() #Elemente aus der Warteschlange entfernen
q.task_done()
print("received:", result) # received: 5
Machen wir dasselbe mit Go.
In Go wird ein leichter Thread, Goroutine, implementiert, der parallel ausgeführt wird. Das Schreiben von go f (x) startet eine neue Goroutine und führt die Funktion aus.
Es verwendet eine Datenstruktur, die als Kanal bezeichnet wird, um Daten zwischen Goroutinen zu übertragen. Der Name des Kanaltyps wird als "chan [Datentyp]" geschrieben.
Go
package main
import (
"fmt"
"time"
)
func newThread(a, b int, ch chan int) {
time.Sleep(1000)
result := a + b
ch <- result //Daten an Kanal senden
fmt.Println("result:", result)
}
func main() {
ch := make(chan int) //Einen Kanal generieren
go newThread(2, 3, ch) //Führen Sie newThread in einer neuen Goroutine aus
fmt.Println("main thread")
result := <-ch //Daten vom Kanal empfangen
close(ch)
fmt.Println("received:", result) // received: 5
}
Ich habe die Go-Sprachgrammatik im Vergleich zu Python gesehen. Obwohl Go eine statisch typisierte Sprache ist, ist es auch so einfach zu schreiben wie eine dynamisch typisierte Sprache wie Python. Da Go von verschiedenen Sprachen beeinflusst werden soll, denke ich, dass jeder, der die C-Sprache versteht, die Zeiger und Strukturen in Go sofort verstehen kann. Ich konnte nicht auf Goroutine und Kanal eingehen, die für die Parallelverarbeitung wichtig sind, aber ich würde sie gerne noch einmal schreiben.