yield ()的序列不起作用
yield()是一个用于暂停和恢复执行的关键字，常用于生成器函数中。当调用yield()时，生成器函数会暂停执行并返回一个值，同时保存当前的执行状态。下次调用生成器函数时，会从上次暂停的地方继续执行，并返回下一个值。
yield()的序列不起作用可能有以下几个原因：
- 生成器函数中没有使用yield关键字：yield()只能在生成器函数中使用，如果没有在生成器函数中使用yield关键字，那么yield()的序列自然不会起作用。
- 生成器函数中没有正确使用yield关键字：在生成器函数中，yield关键字应该用于返回值并暂停执行，如果没有正确使用yield关键字，那么yield()的序列也不会起作用。确保在生成器函数中正确使用yield关键字来返回值。
- 生成器函数没有被正确调用：生成器函数需要通过调用来触发执行，如果没有正确调用生成器函数，那么yield()的序列也不会起作用。确保正确调用生成器函数来触发执行。
总结起来，yield()的序列不起作用可能是由于生成器函数中没有使用或正确使用yield关键字，或者生成器函数没有被正确调用所致。请检查代码中的这些问题，并进行相应的修正。
腾讯云相关产品和产品介绍链接地址：
- 云函数（Serverless）：https://cloud.tencent.com/product/scf
- 云数据库 MySQL 版：https://cloud.tencent.com/product/cdb_mysql
- 云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 人工智能平台（AI Lab）：https://cloud.tencent.com/product/ai
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 区块链服务（Tencent Blockchain）：https://cloud.tencent.com/product/tbc
- 视频处理（云点播）：https://cloud.tencent.com/product/vod
- 物联网开发平台（IoT Explorer）：https://cloud.tencent.com/product/iotexplorer
相关·内容
我有以下方法：
member this.addColumnWithHeading heading column =
this.addColumn (seq { yield heading; yield! (column |> Seq.map string)})
它接受字符串标题和任何序列(在这种情况下被编译为seq )，创建字符串序列，并使用该数据调用另一个方法。但是，当列是一个浮点数序列时，它不起作用：
Error 1 The type 'obj' does not match the type 'float' C:\Users\g
浏览 1提问于2012-08-28得票数 2
回答已采纳
我是F#新手，我编写的代码有问题，由于某些原因，行拆分不起作用，Map.OfArray调用只返回一个空数组。
代码如下：
let loaddata() =
async {
let! csv = sprintf "http://api.bitcoincharts.com/v1/trades.csv?symbol=bitstampUSD" |> fetch
return
[|
for row in csv.Split([|'\n'
浏览 2提问于2014-05-10得票数 1
回答已采纳
1回答
我在从序列构造中调用函数时遇到了问题。显然，函数的调用是如此的懒惰，以至于整个代码都没有产生预期的结果。以下是代码：
mylist
|> fun myseq ->
seq { for b in mylist do yield { b with status = (getStatus b)}}
在这里，我的名单是一个记录的清单。我打算用它构建一个序列，并从函数getStatus更新字段状态。它根本不起作用，函数似乎不像预期的那样为for循环的每一次迭代运行。
感谢你的帮助。
浏览 0提问于2016-02-13得票数 3
回答已采纳
我想在一个单一的for循环中使用两个发电机。类似于：
for a,b,c,d,e,f in f1(arg),f2(arg):
print a,b,c,d,e,f
其中a，b，c，d和e来自f1，f来自f2。由于空间的限制，我需要使用产运算符。
然而，上面的代码不起作用。由于某种原因，它继续从f1获取值(所有六个变量)，直到耗尽为止，然后开始从f2获取值。
请让我知道这是否可能，如果没有，有任何解决办法。提前谢谢你。
浏览 0提问于2014-07-16得票数 0
回答已采纳
2回答
向序列中添加元素
、、
我有一个正在读取的csv文件
Din, Anh , 69
James, Urbank,61
我想在csv字符串中添加另一个名字“Ernest，古巴人，70”，所以我首先用逗号分隔每个值。我开始寻找一个插入函数，并找到了一个，所以我在代码中添加了下面这一行
|>Seq.map (fun values ->
values.[0].Insert(0,"Ernest")),
values.[1].Insert(0,"Cuban")),
float values.[2].Insert(0,"70
浏览 0提问于2014-11-10得票数 1
转到我的问题
我认为这里提出的问题绝不是新问题，但我没有找到任何直接相应的讨论。
假设我有以下函数(为了为具有相同结构属性的'a -> 'a seq类型的真实世界函数提供确定性替代)：
// I'm a function that looks suspiciously like a tree
let lsExample x =
match x with
| 0 -> seq { 1; 6; 7 }
| 1 -> seq { 2; 3 }
| 3 -> seq { 4; 5 }
| 7 -> seq {
浏览 5提问于2021-06-25得票数 3
回答已采纳
let ints = [1..40000]
// create [{1};{2};.....{40000}]
let a1 = ints |> List.map Seq.singleton
// tail recursively append all the inner list
let a2 = a1 |> List.fold Seq.append Seq.empty
// tail recursively loop through them
let a3 = a2 |> Seq.forall (fun x -> true) // stack overflow
浏览 4提问于2014-05-30得票数 5
回答已采纳
5回答
F#中序列表达式中的类型推断
、、、、
我想我不太理解F#是如何推断序列表达式中的类型的，为什么即使我直接从"seq“中指定元素的类型，类型也不能正确识别。
在下面的F#代码中，我们有一个基类A和两个派生类B和C：
type A(x) =
member a.X = x
type B(x) =
inherit A(x)
type C(x) =
inherit A(x)
如果我试图在一个简单的序列表达式中“产生”它们的实例，我会得到两个错误：
// Doesn't work, but it makes sense.
let testSeq = seq {
yield A(0)
浏览 0提问于2013-05-23得票数 9
回答已采纳
3回答
我知道从技术上讲，接口是用来读取的，而不是用来写或编辑的。但是，我想在下面的类中添加一个add和addrange函数，这是我目前拥有的不起作用的函数
public class HrefCollection : IEnumerable<Href>
{
private IEnumerable<Href> hrefs;
public IEnumerable<Href> Add( Href href )
{
yield return href;
}
public IEnumerable<Href&g
浏览 0提问于2010-05-21得票数 10
回答已采纳
我得到了这个错误，Table1是“表”中的外键，我如何修复这个错误？ Foreach语句不能对'Table1‘类型的变量操作，因为'Table1’不包含'GetEnumerator‘的公共实例定义 @if (Model != null)
{
@foreach (var items in Model)
{
@foreach (v
浏览 50提问于2020-07-01得票数 0
回答已采纳
1回答
我有两个带有坐标的列表(每个轴一个)，我正在用它们做正方形： // create all combinations
let squares = List<int * int * int * int>()
seqX
|> Seq.pairwise
|> Seq.iter (fun (x1, x2) ->
seqY
|> Seq.pairwise
|> Seq.iter (fun (y1, y2) -> squares.Add(x1, y1, x2, y2))
) 有没有办法，使用集合函数来实现这一点？我不能使用Seq.ma
浏览 18提问于2020-03-31得票数 1
回答已采纳
1回答
采取下列方法：
public async IAsyncEnumerable<int> Foo()
{
await SomeAsyncMethod();
return Bar(); // Throws since you can not return values from iterators
}
public async IAsyncEnumerable<int> Bar()
{
for(int i = 0; i < 10; i++)
{
await Task.Delay(100);
yield return
浏览 0提问于2020-01-10得票数 18
回答已采纳
1回答
我从F#开始，我不知道构造值初始化的最佳方法是什么：
let x = TryCalculateX() // for example, searching in DB
if x = null then
// for example, we create it ourself and out it into DB
let x = TryAnotherCalcultaion()
someProcessing x // x is now initialized => Ok
someProcessing x // here I use old, not initializ
浏览 3提问于2013-12-17得票数 3
回答已采纳
2回答
这是一个相当微不足道的问题，但在谷歌上快速搜索一下并没有给出答案。
为序列编写递归函数的标准方法是什么？对于列表，您将使用空列表和head+tail模式进行模式匹配，序列的等价物是什么？
浏览 0提问于2012-07-12得票数 5
回答已采纳
3回答
连接生成器和项
、、、
我有一个生成器(numbers)和一个值(number)。我想把它们当作一个序列来迭代：
i for i in tuple(my_generator) + (my_value,)
问题是，据我所知，它创建了3个元组，只是为了立即丢弃它们，并且还复制了一次"my_generator“中的项。
更好的方法是：
def con(seq, item):
for i in seq:
yield seq
yield item
i for i in con(my_generator, my_value)
但是我想知道在没有函数定义的情况下是否可以做到这一点
浏览 0提问于2010-03-15得票数 30
回答已采纳
IEnumerable必须使用收益率才能延迟吗？
下面是帮助我理解延迟执行和产出的测试代码。
//immediate execution
public IEnumerable Power(int number, int howManyToShow)
{
var result = new int[howManyToShow];
result[0] = number;
for (int i = 1; i < howManyToShow; i++)
resu
浏览 0提问于2012-02-14得票数 6
回答已采纳
2回答
我想编写一个扩展方法(用于在流畅的语法中使用它)，以便如果序列是：
List< int> lst = new List< int>(){1,2,3 };
我想重复三次(例如)。所以输出将是123123123
我写了这个：
public static IEnumerable<TSource> MyRepeat<TSource>(this IEnumerable<TSource> source,int n)
{
return Enumerable.Repeat(source,n).SelectMa
浏览 1提问于2013-09-15得票数 0
回答已采纳
2回答
下面的两个代码片段之间有什么区别(如果有的话)？
Scala编程的Ch7示例
def grep(pattern: String) =
for (
file <- filesHere
if file.getName.endsWith(".scala");
line <- fileLines(file)
if line.trim.matches(pattern)
) println(file + ": " + line.trim)
还有这张
def grep2(pattern: String) =
for
浏览 0提问于2010-09-03得票数 18
回答已采纳
3回答
这是我在这个问题上的失败尝试，任何帮助都将不胜感激。
我试着为在渴望列表上工作的power set想出最好的算法。这部分似乎工作得很好。我遇到麻烦的部分是将它转换为序列，这样它就可以在流\无限列表上运行它。我真的不喜欢yield语法，可能是因为我不太理解它，但我宁愿不使用yield语法。
//All Combinations of items in a list
//i.e. the Powerset given each item is unique
//Note: lists are eager so can't be used for infinite
let listCombi
浏览 0提问于2012-01-10得票数 4
回答已采纳
这个函数很好，但是它没有做我想做的事情，但是我使用它来确保对象的使用是正确的：
let getStreamData_ok (uri:string) =
let request = WebRequest.Create uri
use response = request.GetResponse()
use stream = response.GetResponseStream()
use reader = new StreamReader(stream)
while not reader.EndOfStrea
浏览 1提问于2010-11-15得票数 4
回答已采纳
let makeIdGenerator startvalue =
let index : uint64 ref = ref startvalue
fun () ->
let result = !index
index := !index + 1UL
result
我需要的是一个具有unit -> uint64类型的函数的生成器，如上面所示。
上面的代码可以工作，但是使用一个引用变量来回溯生成器的状态。
尝试使用无限序列(如在Seq.initInfinite (fun i -> i)中)并不有效，因为序列本身就使
浏览 2提问于2015-04-14得票数 2
回答已采纳
我想在python中构建一个倒置索引，使用伟大的库来标记单词。
它们提供了一个很好的例子，如何并发地执行预处理，最后得到一个准备索引的文档列表。
texts = [u'One document.', u'...', u'Lots of documents']
# .pipe streams input, and produces streaming output
iter_texts = (texts[i % 3] for i in range(100000000))
for i, doc in enumerate(nlp.pipe(iter_t
浏览 3提问于2017-03-23得票数 0
回答已采纳
1回答
我有一个很大的文本文件("|“分隔)，就像下面这个小例子：
>ENST00000511961.1|ENSG00000013561.13|OTTHUMG00000129660.5|OTTHUMT00000370661.3|RNF14-003|RNF14|278
MSSEDREAQEDELLALASIYDGDEFRKAESVQGGETRIYLDLPQNFKIFVSGNSNECLQNSGFEYTICFLPPLVLNFELPPDYPSSSPPSFTLSGKWLSPTQLSALCKHLDNLWEEHRGSVVLFAWMQFLKEETLAYLNIVSPFELKIGSQKKVQRRTAQASP
浏览 33提问于2018-06-11得票数 -2
下面是生成所有排列的简单代码，基于以下实现：
let concatElement element sequence =
seq {
yield element
yield! sequence
}
let rec permute (choices : 'a seq)=
seq {
if Seq.isEmpty choices then
yield Seq.empty
else
for choice in choices do
浏览 2提问于2016-11-02得票数 2
回答已采纳
我有一个函数f()和一个IEnumerable<string>，我想从它们创建另一个IEnumerable<string>，以便对于原始枚举中的每个字符串s，新的字符串具有s和f(s)。元素的顺序很重要。
示例：
IEnumerable<string> given = { "A", "B", "C" };
IEnumerable<string> wanted = { "A", f("A"), "B",
浏览 0提问于2010-11-11得票数 4
回答已采纳
1回答
我想输出进度消息，而我下载文件和填充我的数据库在我的颤音应用程序。
为此，我使用一个StreamBuilder和一个流，在执行工作时生成状态消息更新。
到目前为止还不错，但是现在除了我的状态消息之外，我还想展示一些关于下载进度的细节。据我所知，我可以将下载进度包装在另一个流中，但现在我有点不知道如何从状态更新流中调用该流。
代码现在看起来是这样的：
Stream<String> _upsertResult(context) async* {
yield "Downloading Identifiers... (1/6)";
await Ident
浏览 0提问于2019-07-06得票数 3
回答已采纳
2回答
我的代码(如下所示)由于堆栈溢出异常而失效。我假设F#不像haskell，它不能很好地处理递归列表。在F#中处理这样的递归列表的正确方法是什么？我是否应该向它传递一个int，这样它就有了一个确定的大小？
let rec collatz num =
match num with
|x when x % 2 = 0 ->num :: collatz (x/2)
|x -> num :: collatz ((x * 3) + 1)
浏览 0提问于2011-11-11得票数 2
回答已采纳
2回答
第一种方法是OK的。第二个不断重复同一对数字。
我不太明白为什么.你能指出好的方向吗？
module Normal =
let rnd = new MersenneTwister()
let sampleNormal =
fun () -> let rec randomNormal() = let u1, u2 = rnd.NextDouble(),rnd.NextDouble()
let r, theta= sqrt (-2. * (log u1)), 2. * System.
浏览 0提问于2012-07-02得票数 4
回答已采纳
我通常使用数组语法从单个值创建一个序列，如下所示：
IEnumerable<string> sequence = new string[] { "abc" };
或者使用新的列表。我很想知道是否有人有更有表现力的方式来做同样的事情。
浏览 5提问于2009-06-19得票数 105
回答已采纳
我有一些来自SQL dB的数据，看起来类似于
recordID value date
A 4 11/20/14
A 1 11/25/14
B 5 01/10/15
B 2 01/20/15
C 10 11/20/14
C 3 11/25/14
C 5 11/30/14
但却有数万排。
我的目标是，对于每个recordID，在应用日期筛选器之后，保留与最近日期相对应的行。
我可以轻松地过滤数据
let filteredData = tab
浏览 1提问于2015-11-10得票数 0
回答已采纳
我想要创建一个函数，它接受一个字符串并返回一个数字序列。如果传递空字符串，则应该返回只包含0的序列。我试着做以下几件事：
let mapToInt (s: string) :seq<int> =
if s.Length = 0 then
seq {0}
else
s.Split ' '
|> Seq.map int
但是，这会产生以下错误消息：
This expression should have type 'unit', but has type 'int'
浏览 4提问于2016-04-07得票数 0
回答已采纳
该函数将两个列表连接在一起：
let append = fun a b -> [ yield! a
yield! b ]
append [1;2;3] [4;5;6]
val it : int list = [1; 2; 3; 4; 5; 6]
但是，如果我删除函数中列表括号开头的空格(比如这个[yield! ... ])，它就不再工作了。
而且，如果我这样做，它会抱怨：
[ yield! a yield! b ]
// or this
[ yield! a
yield! b]
第二个屈服！必须在第一个下面，否则它会抱怨。为什么
浏览 1提问于2018-11-07得票数 1
回答已采纳
1回答
延迟序列栽培马铃薯
、、、
为了种土豆，我正在实施重试模式。如果我不能种植它们，我想再试一次。我实现的第一部分是延迟生成器的集合。
它们的基本类型是DelaySequence：
public abstract class DelaySequence : IEnumerable<TimeSpan>
{
protected DelaySequence(int count) { Count = count; }
public int Count { get; }
public IEnumerator<TimeSpan> GetEnumerator() => Genera
浏览 0提问于2016-11-10得票数 2
回答已采纳
2回答
private IEnumerable<Employee> Source1;
Source1 = Function1(); // Returns Ienumerable<Employee>
ViewState.Add("str", Source1); //ERROR HERE
更新
Function1
public static IEnumerable<Employee> Function1(string id)
{
IEnumerable<Employee> all;
浏览 1提问于2015-05-13得票数 3
3回答
我有两个独立的动作，它们是枚举数。
一个可以独立运行，另一个依赖于第一个之后运行。
我想我这样做会很聪明：
public IEnumerator<IResult> DoStuffIndependently()
{
yield return this;
yield return that;
}
public IEnumerator<IResult> DoStuffBeforeSometimes()
{
yield return AffectThis;
yield return AffectThat;
yield return DoStuf
浏览 2提问于2012-07-18得票数 4
回答已采纳
有时，我在书中看到了F#中用于列表和序列理解的语法：
seq { for i = 0 to System.Int32.MaxValue -> i }
这来自，第80页。在与F#一起提供的VS2010中，它不编译。我相信->已经被否决了。(见)。然而，->仍然可以用于涉及范围的理解：
seq { for c in 'A' .. 'Z' -> c }
根据的第58页，这是因为->是范围内Seq.map的缩写。
为什么上面提到的第一次使用->是不可取的？
目前对->的使用似乎不一致。有人能帮我调和一下吗？
浏览 4提问于2010-11-06得票数 7
4回答
我想生成一个类似于乘法表的序列。因此，对于1的开始和10的停止，我寻找如下的序列
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, // 1*1 - 1*10
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, // 2*1 - 2*10
3, 6, 9, 12, ... // 3*1 - 3*10
这是我的糟糕的开始，然而我似乎不知道如何在到达停止时干净地递增j，或者如何将i重置回开始。
let multable (start,stop) =
(start,start)
|> Seq.unfold(
fun (i,j)
浏览 2提问于2009-09-16得票数 1
回答已采纳
事实证明，这对我来说不是一个微不足道的任务，我找不到任何收据，所以也许你可以给我一个，或者你有一个现成的，适当的和良好的解决方案？正确的含义也适用于不知道自己长度的迭代器(没有__len__)，也适用于不可穷举的迭代器(例如链式迭代器)；良好的调整意味着快速。
注意:就地解决方案是不可能的，因为需要缓存迭代器输出来重新迭代它们(指出了这一点)。
示例用法：
>>> list(izip_cycle(range(2), range(5), range(3)))
[(0, 0, 0), (1, 1, 1), (0, 2, 2), (1, 3, 0), (0, 4, 1)]
>
浏览 0提问于2010-11-09得票数 2
回答已采纳
4回答
我想读取出现在文件中的数据(数据由另一个进程写入)。比如“持续阅读”。
简单的代码将文件读到最后并完成，没有任何问题：
let readStream (r: StreamReader) =
seq {
while not r.EndOfStream do
yield r.ReadLine() }
现在，我向它添加了以下逻辑:如果它到达流的末尾，它将等待一秒钟，然后重试。如果数据没有出现，它会休眠2秒，然后在5次尝试中休眠5秒：
let readStream (r: StreamReader) =
let rec loop waitTimeout waits =
浏览 3提问于2013-11-19得票数 2
我是F#的新成员(但非常兴奋)。
返回F#的属性的等效IEnumerable<object[]>代码是什么？
public static IEnumerable<object[]> EnumerateFooBar
{
get
{
yield return new object[]
{
"foo",
"bar"
};
}
}
浏览 1提问于2013-06-23得票数 1
回答已采纳
2回答
VS2010 Beta2 F#编译器总是抱怨我使用when关键字，即使是在使用复制粘贴的代码时也是如此，比如。例如，这是我在尝试执行一个非常简单的表达式时得到的错误：
“错误FS0010:表达式中的意外关键字'when‘。应为'->’或其他标记。”
[for i in 1..50 when i < 10 -> i]
---------------^^^^
浏览 0提问于2009-12-05得票数 8
回答已采纳
我对Python有点陌生，并且正在进行编程练习。我已经编写了下面的递归方法来根据Python中的输入列表生成。它应该返回一个生成器，该生成器生成作为s传入的给定列表的功率集。电源组中的每个元素都应该是一个集合。
def gps(s, res=set()):
if s:
elem = s.pop()
gps(s, res)
res.add(elem)
gps(s, res)
else:
yield res
然而，当我使用list(gps([1,2]))调用它时，它给了我[]。正确的结果应该是类似于[s
浏览 8提问于2021-06-25得票数 3
回答已采纳
2回答
我正在尝试构建包含多个文件内容的单个序列，以便可以对其进行排序，然后将其传递给绘图组件。然而，我在尝试将每个文件的内容折叠在一起时被卡住了。下面的伪代码不能编译，但希望能显示出我想要实现的意图。
如有任何帮助，不胜感激。
open System.IO
let FileEnumerator filename = seq {
use sr = System.IO.File.OpenText(filename)
while not sr.EndOfStream do
let line = sr.ReadLine()
浏览 0提问于2012-03-20得票数 8
回答已采纳
考虑以下方法：
IEnumerable<DateTime> GetTimes(int count)
{
for (int i = 0; i < count; i++)
yield return DateTime.Now;
yield break;
}
现在，我想把它命名为：
var times = GetTimes(2);
Console.WriteLine("First element:" + times.Take(1).Single().ToString());
Console.WriteLine("Second elemen
浏览 2提问于2012-11-17得票数 1
是否可以序列化一个IEnumerable属性，其中的值是由‘收益率’语句支持的？如果可能的话，怎么做？不是，为什么？
每当我尝试这样做的时候，我都会从NullReferenceException那里得到一个DataContractSerializer。举个例子：
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
namespace IEnumerableTest
{
class Program
{
static void Main(str
浏览 0提问于2012-02-29得票数 4
我试图在python中创建内置map()函数。以下是可能的尝试：
def mapper(func, *sequences):
if len(sequences) > 1:
while True:
list.append(func(sequences[0][0],sequences[0][0],))
return list
return list
但是我真的坚持住了，因为如果用户给出100个参数，我该如何处理这些
浏览 2提问于2017-12-28得票数 3
回答已采纳
我需要这样的东西：
>>> for i in mark_last([1, 2, 3]):
... print(i)
...
(1, False)
(2, False)
(3, True)
我就是这样实现的但是..。
def mark_last(li):
items = iter(items)
try:
prev = next(items)
except StopIteration:
return
for item in items:
yield prev, False
prev
浏览 4提问于2015-03-08得票数 3
回答已采纳
3回答
提高序列的性能
、、
我正在实现Eratosthenes筛的两个版本，第一个版本是必需的：
let primesUntilArray n =
let isqrt x =
let mutable root = 0UL
let mutable p = 1UL <<< 31
while p > 0UL do
while x < (root + p) * (root + p) do
p <- p >>> 1
root <- r
浏览 4提问于2022-01-17得票数 1
回答已采纳
有一种众所周知的解决方案，用于生成无限的汉明数流(即，所有正整数n where n = 2^i * 3^j * 5^k)。我在F#中用两种不同的方式实现了这一点。第一种方法使用seq<int>。解决方案很优雅，但性能很差。第二种方法使用自定义类型，其中尾部包装在Lazy<LazyList<int>>中。解决方案很笨拙，但性能却令人惊叹。
谁能解释一下为什么使用seq<int>的性能这么差，有没有办法解决这个问题？谢谢。
方法1使用seq<int>。
// 2-way merge with deduplication
let rec (
浏览 10提问于2014-07-07得票数 7
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
