Question

我有许多数据文件，每个数据文件都包含大量数据点。

用numpy加载文件后，我得到一个numpy数组：

f=np.loadtxt("...-1.txt")

如何随机选择长度为x的数字，但是数字的顺序不应更改？

例如：

f = [1,5,3,7,4,8]

如果我想选择3个数据点的随机长度，则输出应为：

1,5,3或
3,7,4或
5,3,7等

Answer 1

基于usr2564301的答案，您只能使用范围一次性取出所需的元素，从而避免构建可能非常大的中间数组：

result = f[range(random.randrange(len(f)-x+1), x)]

当长度x变大时，范围还可以避免构建大型索引数组。

Answer 2

纯逻辑将带您到达那里。

对于列表x和最大长度0, len(f)-x，随机切片的有效起点限制为0 1 2 3 f = [1,5,3,7,4,8]：

random.randrange(len(f)-x+1)

因此可以使用+1选择所有有效的起点（其中range是因为的工作方式类似于start）。

将随机起点存储到变量[start:start+x]中，并用result = f[random.randrange(len(f)-x+1):][:3]分割数组，或者要有创造力并在第一个之后使用另一个切片：

package sqs

import (
    "fmt"
    "log"
    "os"
    "runtime"

    "github.com/aws/aws-sdk-go/aws/session"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/service/sqs"
    "github.com/aws/aws-sdk-go/service/sqs/sqsiface"
)

var sess *session.Session
var svc *sqs.SQS
var queueURL string

func init() {
    // Setting the runtime to run with max CPUs available
    runtime.GOMAXPROCS(runtime.NumCPU())

    sess = session.Must(session.NewSessionWithOptions(session.Options{
        SharedConfigState: session.SharedConfigEnable,
    }))

    svc = sqs.New(sess)

    queueURL = os.Getenv("QUEUE_URL")
}

type Poller interface {
    Poll(chan bool)
}

// NewPoller is a factory to create a Poller object
func NewPoller(msgr Messenger) Poller {
    p := &poller{
        m: msgr,
    }
    return p
}

type poller struct {
    m Messenger
}

func (p *poller) Poll(done chan bool) {
    sqsMsgCh := make(chan *sqs.Message, 100)
    for {
        messages, err := p.m.GetMessage()
        if err != nil {
            log.Printf("error when getting message")
            if len(messages) == 0 {
                // Stop the system
                log.Printf("I am here")
                done <- true
            }
        }
        for _, msg := range messages {
            sqsMsgCh <- msg
        }
    }
}

type Messenger interface {
    GetMessage() ([]*sqs.Message, error)
}

func NewMessenger() Messenger {
    return &messenger{
        s: svc,
    }
}

type messenger struct {
    s sqsiface.SQSAPI
}

func (m *messenger) GetMessage() ([]*sqs.Message, error) {
    result, err := m.s.ReceiveMessage(&sqs.ReceiveMessageInput{
        AttributeNames: []*string{
            aws.String(sqs.MessageSystemAttributeNameSentTimestamp),
        },
        MessageAttributeNames: []*string{
            aws.String(sqs.QueueAttributeNameAll),
        },
        QueueUrl:            aws.String(queueURL),
        MaxNumberOfMessages: aws.Int64(10),
        VisibilityTimeout:   aws.Int64(36000), // 10 hours
        WaitTimeSeconds:     aws.Int64(0),
    })

    if err != nil {
        fmt.Println("Error", err)
        return nil, err
    }

    msgs := result.Messages
    if len(msgs) == 0 {
        fmt.Println("Received no messages")
        return msgs, err
    }
    return msgs, nil
}

从numpy数组中随机选择数字的长度

2 个答案: