python traduit en golang

Avant-propos

Python est un langage de programmation de haut niveau largement utilisé. Il est facile à apprendre et à utiliser, possède un code concis et a une efficacité de développement élevée. Il a été largement utilisé dans des domaines tels que la science des données et l'apprentissage automatique. Le langage Go est une étoile montante avec de meilleures performances de concurrence et une plus grande efficacité d’exécution du code. Par conséquent, lorsque nous devons améliorer l’efficacité d’exécution du code Python ou mieux utiliser les ressources multicœurs de l’ordinateur, nous pouvons utiliser le langage Go pour écrire des programmes plus efficaces.

Cet article présente principalement comment traduire le code Python en langage Go et explique comment concevoir et optimiser des programmes en langage Go du point de vue des fonctions Python.

1. Traduire le code Python en langage Go

Avant de traduire le code Python en langage Go, vous devez comprendre les différences et les similitudes entre les deux langages. Python est un langage typé dynamiquement qui met l'accent sur la lisibilité et la simplicité du code. Le langage Go est un langage typé statiquement qui se concentre sur la maintenabilité du code et les capacités de traitement simultané.

Il existe deux façons de traduire le code Python en langage Go. La première consiste à écrire manuellement le code du langage Go et à implémenter la fonction du langage Go correspondante selon la logique du programme Python. La seconde consiste à utiliser les outils de traduction existants, tels que py2go et transcrypt.

Écrivez manuellement le code du langage Go

Voici quelques exemples de traduction du code Python en code du langage Go pour mieux comprendre la relation entre les deux langages.

Code Python :

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

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

Code de langue Go :

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

Voici un autre exemple :

Code Python :

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

Code de langue Go :

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

Utiliser un outil de traduction pour la conversion de code

L'utilisation d'un outil de traduction peut réduire écriture manuscrite Le temps et la charge de travail du codage, comme l'utilisation de l'outil de traduction py2go pour convertir le code Python ci-dessus en code de langue Go :

Code Python :

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

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

Code de langue Go :

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. Concevoir et optimiser les programmes de langue Go à partir de Fonctions Python

Du point de vue des fonctions Python, nous pouvons optimiser les programmes en langage Go des manières suivantes.

1. Déclaration de type des paramètres initiaux

Le langage Go est un langage typé statiquement et les types de paramètres doivent être déclarés lorsque la fonction est définie. Dans le même temps, la méthode de passage de paramètres du langage Go est le passage de valeurs, tandis que la méthode de passage de paramètres de Python est le passage de références.

Code Python :

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]

Code du langage Go :

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

En langage Go, les paramètres doivent être déclarés comme types de slice afin qu'ils puissent être modifiés dans la fonction.

2. L'utilisation d'identifiants vides

L'utilisation d'identifiants vides _ dans le langage Go peut représenter des variables anonymes. Par exemple, en Python, le trait de soulignement _ est généralement utilisé pour remplacer un nom de variable, indiquant que cette variable ne sera pas référencée. dans les utilisations ultérieures.

Code Python :

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

Code du langage Go :

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

Dans le langage Go, utilisez le trait de soulignement _ pour représenter les variables anonymes, mais sa portée est le bloc d'instructions actuel. Par exemple, lors de l'attribution d'une valeur à underscore_, la valeur est ignorée.

3. Programmation orientée interface

Pour le polymorphisme, Python dispose d'une fonctionnalité de typage de canard intégrée, c'est-à-dire que l'applicabilité d'un objet n'est pas basée sur son type, mais sur les méthodes qu'il possède. En langage Go, vous pouvez utiliser des interfaces pour réaliser le polymorphisme.

Par exemple, dans le code ci-dessous, Cat et Dog implémentent tous deux la méthode Say dans l'interface Animal, il n'y a donc pas besoin de se soucier du type réel de l'objet dans la fonction Test, il vous suffit de faire attention à savoir si il implémente l'interface Animal.

Code Python :

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

Code de langue Go :

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. Prise en charge des paramètres facultatifs et des paramètres par défaut

En Python, la méthode d'écriture de prise en charge des paramètres facultatifs et des paramètres par défaut est très flexible, et la valeur par défaut peut être spécifiée dans la définition de la fonction, ou utilisez args et *kwargs pour transmettre des paramètres facultatifs.

Code Python :

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

Dans le langage Go, en raison de la prise en charge de la surcharge de fonctions, la liste des paramètres d'une fonction peut définir différents types de paramètres selon les besoins. Par exemple, dans le code suivant, la surcharge est utilisée pour implémenter des paramètres facultatifs et des valeurs par défaut.

Code du langage Go :

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
}

Résumé

Cet article présente comment convertir le code Python en code du langage Go et, du point de vue des fonctions Python, explique comment déclarer les types de paramètres, utiliser les identifiants d'espaces, la programmation orientée interface et la surcharge. implémente des méthodes telles que les paramètres facultatifs et les valeurs par défaut pour optimiser les programmes en langage Go. Les langages Python et Go ont leurs propres caractéristiques, avantages et inconvénients, ainsi que le choix spécifique du langage à prendre en compte en fonction de la situation spécifique. Enfin, merci d'avoir lu!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!