标签: generator

只是想知道是否有人使用ToneGenerator类来使用任何示例代码？我想在大约200Hz到900Hz的频率范围内产生音调.谢谢...

python生成器是列表的良好替代品,在大多数情况下,我希望检查空条件,这是普通生成器无法实现的.我正在尝试编写一个包装器,它将允许检查空状态,但仍然是懒惰的并且提供了生成器的好处.

class mygen:
  def __init__(self,iterable):
    self.iterable = (x for x in iterable)
    self.peeked = False
    self.peek = None
  def __iter__(self):
    if self.peeked:
      yield self.peek
      self.peeked = False
    for val in self.iterable:
      if self.peeked:
        yield self.peek
        self.peeked = False
      yield val
    if self.peeked:
      yield self.peek
      self.peeked = False
  def __nonzero__(self):
    if self.peeked:
      return True
    try:
      self.peek = self.iterable.next()
      self.peeked = True
      return True
    except:
      return False

1. 我认为它的行为像普通的发电机一样.有什么角落我不见了吗？
2. 这看起来并不优雅.是否有更好的更多pythonic方式做同样的事情？

样品用法:

def get_odd(l):
    return mygen(x for x in l if x%2)

def print_odd(odd_nums): …

我使用以下生成器来计算移动平均值:

import itertools
from collections import deque
    def moving_average(iterable, n=50):
    it = iter(iterable)
    d = deque(itertools.islice(it, n-1))
    d.appendleft(0)
    s = sum(d)
    for elem in it:
        s += elem - d.popleft()
        d.append(elem)
        yield s / float(n)

我可以打印发生器输出,但我无法弄清楚如何将该输出保存到文本文件中.

x = (1,2,2,4,1,3)
avg = moving_average(x,2)
for value in avg:
    print value

当我更改打印行以写入文件时,输出将打印到屏幕上,创建一个文件但它保持为空.

提前致谢.

我正在围绕新的ecma6生成器和javascript中的yield-operator,特别是在koa的环境中.

考虑一个人为的例子:

  newUser.save(function(err, user) {
    if(err){
      //do something with the error
    }
    console.log("user saved!: " user.id);
  }

'Yieldified'这看起来像这样:

  var user = yield newUser.save();
  console.log("user saved!: " user.id);

但是err为了执行目的,我将如何检查存在//do something with the error？

我正在尝试Matrix为本书中的示例编写扩展,稍微调整为通用.
我正在尝试编写一个调用方法getRow,该方法返回给定行的值序列.

在C#中,我会写这个:

IEnumerable<T> GetRow (int row)
{
    return Enumerable
        .Range (0, this.columns)
        .Select ((column) => this.grid[row, columns]);
}

或者

IEnumerable<T> GetRow (int row)
{
    for (var column = 0; column < this.columns; column++) {
        yield return this.grid[row, column];
    }
}

我不知道如何在Swift中做到这一点.

Sequence似乎是等价的,IEnumerable<T>但我不明白它为什么使用typealias而不仅仅被定义为Sequence<T>(另见这一点).定义返回泛型的方法Sequence<T>不起作用:

extension Matrix {
    // Cannot specialize non-generic type 'Sequence'
    func getRow<T>(index: Int) -> Sequence<T> {
        return map(0..self.columns, { self[index, $0] …

我正在使用生成器调试一些代码,并提出了这个问题.假设我有一个生成器功能

def f(x):
    yield x

和一个返回生成器的函数:

def g(x):
    return f(x)

他们肯定会回归同样的事情.在Python代码中交替使用它们会有什么不同吗？有没有办法区分这两个(没有inspect)？

我有一个generateNumbers用JavaScript 调用的生成器和另一个生成器generateLargerNumbers,它生成每个生成的值并向其generateNumbers应用一个函数addOne,如下所示:

function addOne(value) {
  return value + 1
}

function* generateNumbers() {
  yield 1
  yield 2
  yield 3
}

function* generateLargerNumbers() {
  for (const number of generateNumbers()) {
    yield addOne(number)
  }
}

如果没有从生成的值中构建数组,是否有任何更简单的方法可以做到这一点？我想的是:

function* generateLargerNumbers() {
  yield* generateNumbers().map(addOne) // obviously doesn't work
}

内容：

我目前正在使用带有Tensorflow后端的Keras进行时间序列预测，因此研究了此处提供的教程。

在学习完本教程之后，我开始fit_generator()描述该方法的生成器。该生成器生成的输出如下（左侧示例，右侧目标）：

[[[10. 15.]
  [20. 25.]]] => [[30. 35.]]     -> Batch no. 1: 2 Samples | 1 Target
  ---------------------------------------------
[[[20. 25.]
  [30. 35.]]] => [[40. 45.]]     -> Batch no. 2: 2 Samples | 1 Target
  ---------------------------------------------
[[[30. 35.]
  [40. 45.]]] => [[50. 55.]]     -> Batch no. 3: 2 Samples | 1 Target
  ---------------------------------------------
[[[40. 45.]
  [50. 55.]]] => [[60. 65.]]     -> Batch no. 4: 2 Samples | 1 Target
  ---------------------------------------------
[[[50. 55.]
  [60. 65.]]] => …

我正在使用一个深层的CNN + LSTM网络对一维信号的数据集进行分类。我使用的keras 2.2.4后盾tensorflow 1.12.0。由于我的数据集很大且资源有限，因此我在训练阶段使用了生成器将数据加载到内存中。首先，我尝试了这个生成器：

def data_generator(batch_size, preproc, type, x, y):
    num_examples = len(x)
    examples = zip(x, y)
    examples = sorted(examples, key = lambda x: x[0].shape[0])
    end = num_examples - batch_size + 1
    batches = [examples[i:i + batch_size] for i in range(0, end, batch_size)]

    random.shuffle(batches)
    while True:
        for batch in batches:
            x, y = zip(*batch)
            yield preproc.process(x, y)

使用上述方法，我可以一次以最多30个样本的小批量启动训练。但是，这种方法不能保证网络每个时期每个样本仅训练一次。考虑来自Keras网站的评论：

Sequence是进行多处理的更安全方法。这种结构保证了网络在每个时期的每个样本上只会训练一次，而生成器则不会。

我尝试了使用以下类加载数据的另一种方式：

class Data_Gen(Sequence):

def __init__(self, batch_size, preproc, type, x_set, y_set):
    self.x, self.y = np.array(x_set), np.array(y_set) …

我试图理解ES2015中的生成器,并用它创建了一个递归因子函数.但它不起作用.我已经提到已经存在的问题像这样的话题,但它并不能帮助.

function* fact (n) {
   if (n < 2) {
     yield 1;
   } else {
     yield* (n * fact(n-1));
   }
}

let b = fact(5);
console.log(b.next()); 

任何人都可以找到我在这里缺少的明显问题吗？我在JSFiddle中使用它与JavaScript-1.7 在这里