Python in Golang übersetzt

Vorwort

Python ist eine weit verbreitete Programmiersprache auf hohem Niveau. Sie ist einfach zu erlernen und zu verwenden, verfügt über einen prägnanten Code und weist eine hohe Entwicklungseffizienz auf. Sie wird häufig in Bereichen wie Datenwissenschaft und maschinellem Lernen eingesetzt. Die Go-Sprache ist ein aufstrebender Stern mit besserer Parallelitätsleistung und höherer Effizienz bei der Codeausführung. Wenn wir daher die Ausführungseffizienz von Python-Code verbessern oder die Multi-Core-Ressourcen des Computers besser nutzen müssen, können wir die Go-Sprache verwenden, um effizientere Programme zu schreiben.

In diesem Artikel wird hauptsächlich die Übersetzung von Python-Code in die Go-Sprache vorgestellt und das Entwerfen und Optimieren von Go-Sprachprogrammen aus der Perspektive der Python-Funktionen erläutert.

1. Python-Code in die Go-Sprache übersetzen

Bevor Sie Python-Code in die Go-Sprache übersetzen, müssen Sie die Unterschiede und Ähnlichkeiten zwischen den beiden Sprachen verstehen. Python ist eine dynamisch typisierte Sprache, die Wert auf Lesbarkeit und Einfachheit des Codes legt. Die Go-Sprache ist eine statisch typisierte Sprache, die sich auf die Wartbarkeit des Codes und die Fähigkeit zur gleichzeitigen Verarbeitung konzentriert.

Es gibt zwei Möglichkeiten, Python-Code in die Go-Sprache zu übersetzen. Eine besteht darin, Go-Sprachcode manuell zu schreiben und die entsprechende Go-Sprachfunktion gemäß der Logik des Python-Programms zu implementieren. Die zweite besteht darin, vorhandene Übersetzungstools wie py2go und transcrypt zu verwenden.

Manuelles Schreiben von Go-Sprachcode

Hier sind einige Beispiele für die Übersetzung von Python-Code in Go-Sprachcode, um die Beziehung zwischen den beiden Sprachen besser zu verstehen.

Python-Code:

def fib(n):
    if n <= 1:
        return n
    else:
        return (fib(n-1) + fib(n-2))

print([fib(i) for i in range(10)])

Go-Sprachcode:

package main

import "fmt"

func fib(n int) int {
    if n <= 1 {
        return n
    } else {
        return (fib(n-1) + fib(n-2))
    }
}

func main() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", fib(i))
    }
}

Hier ist ein weiteres Beispiel:

Python-Code:

def merge_sort(lst):
    if len(lst) <= 1:
        return lst
    mid = len(lst) // 2
    left = merge_sort(lst[:mid])
    right = merge_sort(lst[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result

print(merge_sort([3, 1, 4, 2, 5]))

Go-Sprachcode:

package main

import "fmt"

func mergeSort(lst []int) []int {
    if len(lst) <= 1 {
        return lst
    }
    mid := len(lst) / 2
    left := mergeSort(lst[:mid])
    right := mergeSort(lst[mid:])
    return merge(left, right)
}

func merge(left []int, right []int) []int {
    result := []int{}
    i, j := 0, 0
    for i < len(left) && j < len(right) {
        if left[i] < right[j] {
            result = append(result, left[i])
            i++
        } else {
            result = append(result, right[j])
            j++
        }
    }
    result = append(result, left[i:]...)
    result = append(result, right[j:]...)
    return result
}

func main() {
    lst := []int{3, 1, 4, 2, 5}
    fmt.Println(mergeSort(lst))
}

Verwenden Sie ein Übersetzertool für die Codekonvertierung

Verwenden Sie einen Übersetzer Werkzeug kann reduzieren Handschrift Der Zeit- und Arbeitsaufwand des Codierens, z. B. die Verwendung des py2go-Übersetzungstools zum Konvertieren des oben genannten Python-Codes in Go-Sprachcode:

Python-Code:

def fib(n):
    if n <= 1:
        return n
    else:
        return (fib(n-1) + fib(n-2))

print([fib(i) for i in range(10)])

Go-Sprachcode:

package main

import (
    "fmt"
)

func fib(n int) int {
    if n <= 1 {
        return n
    } else {
        return (fib(n-1) + fib(n-2))
    }
}

func main() {
    var lst []int
    for i := 0; i < 10; i++ {
        lst = append(lst, fib(i))
    }
    fmt.Println(lst)
}

2. Entwerfen und optimieren Sie Go-Sprachprogramme von Python-Funktionen

Aus der Perspektive der Python-Funktionen können wir Go-Sprachprogramme auf folgende Weise optimieren.

1. Typdeklaration der Anfangsparameter

Die Go-Sprache ist eine statisch typisierte Sprache und Parametertypen müssen beim Definieren der Funktion deklariert werden. Gleichzeitig ist die Parameterübergabemethode der Go-Sprache die Wertübergabe, während die Parameterübergabemethode von Python die Referenzübergabe ist.

Python-Code:

def add(x, y):
    x.append(y)
    return x

lst = [1, 2, 3]
print(add(lst, 4))    # [1, 2, 3, 4]
print(lst)            # [1, 2, 3, 4]

Go-Sprachcode:

func add(x []int, y int) []int {
    x = append(x, y)
    return x
}

func main() {
    lst := []int{1, 2, 3}
    fmt.Println(add(lst, 4))    // [1 2 3 4]
    fmt.Println(lst)            // [1 2 3]
}

In der Go-Sprache müssen Parameter als Slice-Typen deklariert werden, damit sie in der Funktion geändert werden können.

2. Die Verwendung leerer Bezeichner

Die Verwendung leerer Bezeichner _ in der Go-Sprache kann anonyme Variablen darstellen. In Python wird beispielsweise der Unterstrich _ normalerweise verwendet, um einen Variablennamen zu ersetzen, der angibt, dass auf diese Variable nicht verwiesen wird bei späteren Nutzungen.

Python-Code:

x, _, y = (1, 2, 3)
print(x, y)    # 1 3

Go-Sprachcode:

x, _, y := []int{1, 2, 3}
fmt.Println(x, y)    // 1 3

In der Go-Sprache verwenden Sie den Unterstrich _, um anonyme Variablen darzustellen, aber sein Gültigkeitsbereich ist der aktuelle Anweisungsblock. Wenn Sie beispielsweise underscore_ einen Wert zuweisen, wird der Wert verworfen.

3. Schnittstellenorientierte Programmierung

Für Polymorphismus verfügt Python über eine integrierte Ententypisierungsfunktion, d. h. die Anwendbarkeit eines Objekts basiert nicht auf seinem Typ, sondern auf den Methoden, über die es verfügt. In der Go-Sprache können Sie Schnittstellen verwenden, um Polymorphismus zu erreichen.

Im folgenden Code implementieren beispielsweise sowohl Cat als auch Dog die Say-Methode in der Animal-Schnittstelle, sodass Sie sich nicht um den tatsächlichen Typ des Objekts in der Testfunktion kümmern müssen, sondern nur darauf achten müssen, ob Es implementiert die Animal-Schnittstelle.

Python-Code:

class Animal:
    def say(self):
        pass

class Cat(Animal):
    def say(self):
        return 'meow'

class Dog(Animal):
    def say(self):
        return 'bark'

def test(animal):
    print(animal.say())

test(Cat())    # meow
test(Dog())    # bark

Go-Sprachcode:

type Animal interface {
    Say() string
}

type Cat struct {
}

func (c *Cat) Say() string {
    return "meow"
}

type Dog struct {
}

func (d *Dog) Say() string {
    return "bark"
}

func Test(animal Animal) {
    fmt.Println(animal.Say())
}

func main() {
    Test(&Cat{})    // meow
    Test(&Dog{})    // bark
}

4. Unterstützung optionaler Parameter und Standardparameter

In Python ist die Schreibmethode zur Unterstützung optionaler Parameter und Standardparameter sehr flexibel und der Standardwert kann in angegeben werden die Funktionsdefinition oder verwenden Sie args und *kwargs, um optionale Parameter zu übergeben.

Python-Code:

def func(a, b=10, *args, **kwargs):
    print(a, b)
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(key, value)

func(1)    # 1 10
func(2, 3)    # 2 3
func(4, 5, 6, 7, eight=8, nine=9)    # 4 5 6 7 eight 8 nine 9

In der Go-Sprache kann die Parameterliste einer Funktion aufgrund der Unterstützung für Funktionsüberladung je nach Bedarf verschiedene Parametertypen definieren. Im folgenden Code wird beispielsweise Überladung verwendet, um optionale Parameter und Standardwerte zu implementieren.

Go-Sprachcode:

func Func(a int, b int) {
    fmt.Println(a, b)
}

func Func2(a int, b int, args ...int) {
    fmt.Println(a, b)
    for _, arg := range args {
        fmt.Println(arg)
    }
}

func Func3(a int, kwargs map[string]int) {
    fmt.Println(a)
    for key, value := range kwargs {
        fmt.Println(key, value)
    }
}

func main() {
    Func(1, 10)    // 1 10
    Func(2, 3)    // 2 3
    Func2(4, 5, 6, 7)    // 4 5 6 7
    kwargs := map[string]int{"eight": 8, "nine": 9}
    Func3(4, kwargs)    // 4 eight 8 nine 9
}

Zusammenfassung

In diesem Artikel wird erläutert, wie Python-Code in Go-Sprachcode konvertiert wird. Aus der Perspektive von Python-Funktionen wird erläutert, wie Parametertypen deklariert, Leerzeichen-IDs verwendet, schnittstellenorientierte Programmierung und Überladung durchgeführt werden implementiert Methoden wie optionale Parameter und Standardwerte, um Go-Sprachprogramme zu optimieren. Sowohl die Python- als auch die Go-Sprache haben ihre eigenen Merkmale, Vor- und Nachteile, und die spezifische Wahl der Sprache muss je nach Situation berücksichtigt werden. Zum Schluss vielen Dank fürs Lesen!

Das obige ist der detaillierte Inhalt vonPython in Golang übersetzt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!