Dictionary 套用辞典

Go代码：

package main

import (
    "bufio"
    _ "bytes"
    "fmt"
    _ "io"
    "log"
    "os"
    "os/user"
    "path/filepath"
    _ "reflect"
    "regexp"
    "runtime"
    "strconv"
    "strings"
    "sync"
    "time"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
    "github.com/aws/aws-sdk-go/service/s3/s3manager"
)

var (
    LocalDirectory   = "s3logs" // Into this directory
    Lock             sync.Mutex
    totalImpressions int
)

var data = make(map[string]map[string]int)

func main() {
    start := time.Now()
    // by adding this line i'm telling the program to run the threads on 4 different cores at the same time, Parallelism!!
    //REMEMBER TO ADD BLOCKS TO STOP RACE CONDITIONS
    runtime.GOMAXPROCS(4)
    var wg sync.WaitGroup

    var year, month, day = time.Now().Date()
    str_year := strconv.Itoa(year)
    str_month := strconv.Itoa(int(month))
    str_day := strconv.Itoa(day)

    if int(month) < 10 {
        str_month = "0" + strconv.Itoa(int(month))
    }
    if day < 10 {
        str_day = "0" + strconv.Itoa(day)
    }

    regBuckets := map[string]string{
        "us-west-1": "pubgears-ca",
        "test":      "test",
    }

    for region, bucket := range regBuckets {
        prefix := fmt.Sprintf("tagserver/logs/AWSLogs/978380792767/elasticloadbalancing/%s/%s/%s/%s/", region, str_year, str_month, str_day)
        wg.Add(1)
        go getLogs(region, bucket, LocalDirectory+bucket, &prefix, &wg)
    }
    wg.Wait()

    //salon/t1/728x90/index
    //totalImpressions := 0
    // var provider = make(map[string]int)
    // for key, value := range data {
    //   key = strings.TrimSpace(key)
    //   pro := strings.Split(key, "_")[3]
    //
    //   if strings.Contains(pro, "pp") == true || (pro == "pulsepoint") || (pro == "cweb") {
    //     provider["pulsepoint"] += value
    //   } else if (pro == "openx") || (pro == "openx3") {
    //     provider["openx"] += value
    //   } else if key == " " {
    //     continue
    //   } else {
    //     provider[pro] += value
    //   }
    //   totalImpressions += value
    // }

    for tag, value := range data {
        for hour, imp := range value {
            fmt.Printf("tag: %s  \n hour: %s impression %s\n", tag, hour, imp)
        }
    }

    //sl = sl[:len(sl)-1]

    elapsed := time.Since(start)
    fmt.Printf("\nTime took %s\n", elapsed)

}

func getLogs(region string, bucket string, directory string, prefix *string, wg *sync.WaitGroup) {
    sess := session.New()
    client := s3.New(sess, &aws.Config{Region: aws.String(region)})

    params := &s3.ListObjectsInput{Bucket: &bucket, Prefix: prefix}
    manager := s3manager.NewDownloaderWithClient(client, func(d *s3manager.Downloader) {
        d.PartSize = 5 * 1024 * 1024 // 6MB per part
        d.Concurrency = 4
    })
    d := downloader{bucket: bucket, dir: directory, Downloader: manager}
    client.ListObjectsPages(params, d.eachPage)
    wg.Done()
}

// downloader object and methods
type downloader struct {
    *s3manager.Downloader
    bucket, dir string
}

func (d *downloader) eachPage(page *s3.ListObjectsOutput, more bool) bool {
    for _, obj := range page.Contents {
        // fmt.Println(obj)
        //     return true
        d.downloadToFile(*obj.Key)
    }
    return true
}

func (d *downloader) downloadToFile(key string) {
    // Create the directories in the path
    // desktop path
    user, errs := user.Current()
    if errs != nil {
        panic(errs)
    }
    homedir := user.HomeDir
    desktop := homedir + "/Desktop/" + d.dir
    file := filepath.Join(desktop, key)
    if err := os.MkdirAll(filepath.Dir(file), 0775); err != nil {
        panic(err)
    }

    // Setup the local file
    fd, err := os.Create(file)
    if err != nil {
        panic(err)
    }
    defer fd.Close()

    // Download the file using the AWS SDK
    //fmt.Printf("Downloading s3://%s/%s to %s...\n", d.bucket, key, file)
    params := &s3.GetObjectInput{Bucket: &d.bucket, Key: &key}
    d.Download(fd, params)
    _, e := d.Download(fd, params)
    if e != nil {
        panic(e)
    }

    f, err := os.Open(file)
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()

    tag := regexp.MustCompile("/([a-zA-Z0-9_]+/{1}[a-zA-Z0-9_]+/{1}[a-zA-Z0-9_]+/{1}[a-zA-Z0-9_]+)")
    date := regexp.MustCompile("T([^:]+)")
    scanner := bufio.NewScanner(f)

    // HAVING TROUBLE HERE
    for scanner.Scan() {
        //dateCollection := make(map[string]int)
        m := tag.FindString(scanner.Text())
        if m != "" {
            // stop races
            Lock.Lock()
            arr := strings.Split(m, "/")
            taghash := strings.Join(arr, "_")
            taghash = strings.TrimLeft(taghash, "_")
            //data[taghash]++
            m = date.FindString(scanner.Text())
            if m != "" {
                hour := m
                data[taghash] = make(map[string]int)
                data[taghash][hour]++
            }
            Lock.Unlock()
        }
    }
    fmt.Println(file)
    os.Remove(file)
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}

打印主函数中的值时得到的输出

fstvt1_ros_300x600_pp8_1 T07 1

我希望得到如下输出：

fstvt1_ros_300x600_pp8_1
T00 213434
T01 23432
T02 3324
T03 324
T04 324
T05 0 ...
(this isn't real data)

我想做什么： 我有一个数据映射

var data=make（map[string]map[string]int）

，其键等于taghash，例如

fstvt1\u ros\u 300x600\u pp8\u 1

。该值是数据的映射。该映射的键值应为字符串和整数。我想要多张地图。每把钥匙一个。。。T01，T02。。当前输出的是我迭代的最后一个项目中的最后一个项目，而不是每个taghash的键和值的集合。我如何使其不覆盖数据，而是添加新的键值T01、T02。。如果taghash和hour是递增该特定对象的时间

我当前使用的代码行：

T01，T02

data[taghash][hour]++

如果taghash和hour存在，则应递增。如果taghash和hour不存在，则创建taghash并添加新的键和增量。

错误来自

data[taghash] = make(map[string]int)

这将每次通过将

数据[taghash]

设置为新分配的映射。这绝对不是你想要做的。相反：

if _, ok := data[taghash]; !ok {
    // data[taghash] does not exist -- create it!
    data[taghash] := make(map[string]int)
}
data[taghash][hour]++

这相当于：

# Python
data.setdefault(taghash, {}).setdefault(hour, 0) += 1

或

---

如果我以后有更多的时间，我可能会找到一个答案，但有一些事情可能会有所帮助。。。首先，Go中没有字典类型，它是一个地图，其次，纯文本中的数据与地图类型不一致。你说你有一个单键字典和一组字典？不，你没有。

foobar\u openx

有一个对象作为值，该对象包含两个未命名的对象。你没有钥匙，所以你肯定没有地图。与您发布内容最接近的结构是数组或切片。很抱歉，您的回答是正确的，我在玩地图时会使用地图，我的思维词典（key:value）。在python中，我的值是一组字典，其中每个字典都有一个键，即时间和印象值。所以我现在就修好结构，我明白我的错误了。即便如此，那也是一个键入错误我是我的一部分，go代码并没有反映这一点。最内部的对象应该是

type Views struct{hours，impressions int}

，而

foobar_openx

应该是该类型的切片或数组<代码>[]视图。您正在尝试解析您发布的数据吗？您不只是使用json有什么原因吗？为什么是这种格式？它类似于json，但我认为这不是有效的json（无论是字典还是数组，都没有值的键）。JSON只是一种表示数据的格式，它与Python中的字典没有连接。Python类型几乎可以接受任何东西，了解json的结构会对您有所帮助，因为再一次，即使在json中，它也不是字典。它们有数组、字典和对象，json和Go中的东西从来都不是字典。无意冒犯，但您只需要了解数据结构，因为您在Python中再次提到的东西，它的约定非常快速和松散，很明显，您并不真正理解Go中需要的数据结构，因为它的约定非常严格，json也是如此。上面描述的结构是数据的文本表示，与程序中数据的表示方式完全不对应。您在Python中使用的集合是超级抽象的，它比您在上面发布的内容要多得多，这就是它为您打印的内容。我已经更改了代码的结构。我也不知道上限，因此代码必须处理未知数量的数据（自行增长）。@msanti它知道，

cap

只是切片的效率问题。增加切片也有成本（因为它必须分配一个新的备份阵列），每小时都应该是它自己的关键。为了像data[taghash][hour]->impression#一样访问它，我在上面发布的代码提供了一个结构，我只需要找出为什么它不能正确地添加值。请注意，我完全同意@evanmcdonnal在问题注释中的观点，即您的数据结构可以使用work。这应该可以很快地查找

hash+hour->views

，但前提是您已经有了hash和hour。实际上，与Python相比，从这个映射中提取数据是非常困难的。@msanti这里有一些事情。有

if；{…}

语法，这里有

值，ok:=mapping[key]

语法。前者允许您编写一条语句来初始化

if

块（与i:=0；i<10；i++块的

中的第一条语句不同。后者允许您从映射中提取值，并通过检查
ok
确保它存在。我们实际上并不关心这里的值，因此使用空变量将其清空。
# Python
data.setdefault(taghash, {}).setdefault(hour, 0) += 1

if taghash not in data:
    data[taghash] = {}
if hour not in data[taghash]:
    data[taghash][hour] = 1
else:
    data[taghash][hour] += 1