ular sawa diterjemahkan kepada golang

Kata Pengantar

Python ialah bahasa pengaturcaraan peringkat tinggi yang digunakan secara meluas Ia mudah dipelajari dan digunakan, mempunyai kod yang ringkas dan mempunyai kecekapan pembangunan yang tinggi. Ia telah digunakan secara meluas dalam bidang seperti sains data dan pembelajaran mesin. Bahasa Go ialah bintang yang semakin meningkat dengan prestasi serentak yang lebih baik dan kecekapan menjalankan kod yang lebih tinggi. Oleh itu, apabila kita perlu meningkatkan kecekapan menjalankan kod Python atau menggunakan sumber berbilang teras komputer dengan lebih baik, kita boleh menggunakan bahasa Go untuk menulis atur cara yang lebih cekap.

Artikel ini terutamanya memperkenalkan cara menterjemah kod Python ke dalam bahasa Go, dan membincangkan cara mereka bentuk dan mengoptimumkan program bahasa Go dari perspektif fungsi Python.

1. Terjemahan kod Python ke dalam bahasa Go

Sebelum menterjemah kod Python ke dalam bahasa Go, anda perlu memahami perbezaan dan persamaan antara kedua-dua bahasa. Python ialah bahasa yang ditaip secara dinamik yang menekankan kebolehbacaan dan kesederhanaan kod. Bahasa Go ialah bahasa ditaip secara statik yang memfokuskan pada kebolehselenggaraan kod dan keupayaan pemprosesan serentak.

Terdapat dua cara untuk menterjemah kod Python ke dalam bahasa Go. Satu ialah menulis kod bahasa Go secara manual dan melaksanakan fungsi bahasa Go yang sepadan mengikut logik program Python. Yang kedua ialah menggunakan alat terjemahan sedia ada, seperti py2go dan transcrypt.

Tulis kod bahasa Go secara manual

Berikut memperkenalkan beberapa contoh menterjemah kod Python ke dalam kod bahasa Go untuk lebih memahami hubungan antara kedua-dua bahasa.

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

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

Berikut ialah contoh lain:

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

Go Language kod:

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

Gunakan alat terjemahan untuk penukaran kod

Menggunakan alat terjemahan boleh mengurangkan masa dan beban kerja kod tulisan tangan Contohnya, gunakan alat terjemahan py2go untuk menukar kod Python di atas kepada Go Kod bahasa:

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

Kod bahasa 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 Reka dan optimumkan program bahasa Go dari perspektif fungsi Python

Daripada perspektif fungsi Python , kami boleh mengoptimumkan program bahasa Go dengan cara berikut.

1. Jenis pengisytiharan parameter awal

Bahasa Go ialah bahasa yang ditaip secara statik dan jenis parameter perlu diisytiharkan apabila fungsi ditakrifkan. Pada masa yang sama, kaedah lulus parameter bagi bahasa Go ialah lulus nilai, manakala kaedah lulus parameter Python ialah lulus rujukan.

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

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

Dalam bahasa Go, parameter perlu diisytiharkan sebagai jenis kepingan supaya ia boleh diubah suai dalam fungsi.

2. Penggunaan pengecam kosong

Pengecam kosong _ dalam bahasa Go boleh mewakili pembolehubah tanpa nama Contohnya, dalam Python, garis bawah _ biasanya digunakan untuk menggantikan pembolehubah nama. Menunjukkan bahawa pembolehubah ini tidak akan dirujuk dalam penggunaan berikutnya.

Kod Python:

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

Kod bahasa Go:

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

Dalam bahasa Go, gunakan garis bawah _ untuk mewakili pembolehubah tanpa nama, tetapi skopnya ialah blok pernyataan semasa. Sebagai contoh, apabila memberikan nilai kepada underscore_, nilai tersebut dibuang.

3. Pengaturcaraan berorientasikan antara muka

Untuk polimorfisme, Python mempunyai ciri menaip itik terbina dalam, iaitu, kebolehgunaan objek tidak berdasarkan jenisnya , tetapi Berdasarkan kaedah yang ada. Dalam bahasa Go, anda boleh menggunakan antara muka untuk mencapai polimorfisme.

Sebagai contoh, dalam kod berikut, kedua-dua Cat dan Dog melaksanakan kaedah Sebut dalam antara muka Haiwan, jadi tidak perlu mengambil berat tentang jenis sebenar objek dalam fungsi Ujian, anda hanya perlu beri perhatian sama ada ia melaksanakan antara muka Haiwan.

Kod 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

Kod bahasa 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. Menyokong parameter pilihan dan lalai

Dalam Python, Kaedah penulisan yang menyokong parameter pilihan dan parameter lalai adalah sangat fleksibel Anda boleh menentukan nilai lalai dalam definisi fungsi, atau gunakan args dan *kwargs untuk lulus parameter pilihan.

Kod 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

Dalam bahasa Go, disebabkan sokongan untuk lebihan fungsi, senarai parameter fungsi boleh menentukan jenis parameter yang berbeza mengikut keperluan. Sebagai contoh, dalam kod berikut, lebihan beban digunakan untuk melaksanakan parameter pilihan dan nilai lalai.

Kod bahasa 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
}

Ringkasan

Artikel ini memperkenalkan cara menukar kod Python kepada kod bahasa Go, dan dari perspektif fungsi Python, membincangkan cara mengisytiharkan parameter Jenis, menggunakan pengecam ruang putih, pengaturcaraan berorientasikan antara muka dan lebihan beban untuk melaksanakan parameter pilihan dan nilai lalai ialah cara untuk mengoptimumkan program bahasa Go. Kedua-dua bahasa Python dan Go mempunyai ciri, kelebihan dan kekurangan mereka sendiri, dan pilihan khusus bahasa mana yang perlu dipertimbangkan berdasarkan situasi tertentu. Akhir sekali, terima kasih kerana membaca!

Atas ialah kandungan terperinci ular sawa diterjemahkan kepada golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!