错误是什么意思是“不能转换类型的价值”？

Question

python代码作为基础：在此处输入链接描述 每个周期发生错误 很多错误（请帮助修复它）：

在此处输入图像描述

代码：

var t = readLine()!
var s = readLine()!
var len_s = s.count
var t_lis = Set(t)
let character:[Character] = Array(s)
var c_s:[Character: Int] = Dictionary(uniqueKeysWithValues: zip(character, Array(repeating: 1, count: character.count)))
let character2:[Character] = Array(t_lis)
var c_t:[Character: Int] = Dictionary(uniqueKeysWithValues: zip(character2, Array(repeating: 1, count: character2.count)))

var c_res = [String: String]()
var summ  = 0
for e in c_s{
    c_res[e] = [c_s[e], min( c_s[e], c_t[e] )]
    summ += c_res[e][1]}
for i in 0..<((t.count-s.count)+1)  {
    if summ == len_s-1{
        print(i)
        break
        
    }
    for j in c_res{
        if t[i] = c_res[j]{
            if c_res[t[i]][1] > 0{
            c_res[t[i]][1] -= 1
            summ -= 1
            }}}
    for l in c_res {
        if (i+len_s < t.count && t[i+len_s]) = c_res{
        if c_res[ t[i+len_s] ][1] < c_res[ t[i+len_s] ][0]{
            c_res[ t[i+len_s] ][1] += 1
            summ += 1
        
        }}}
    
    }

Answer 1

作为参考，这是链接到的原始Python代码：

t = input('t = ')
s = input('s = ')
len_s = len(s)
t_lis = list(t)
c_s   = Counter(s)
c_t   = Counter(t_lis[:len_s])
c_res = dict()
summ  = 0
for e in c_s:
    c_res[e] = [c_s[e], min( c_s[e], c_t[e] )]
    summ += c_res[e][1]
for i in range( len(t)-len(s)+1 ):
    if summ == len_s-1:
        print(i)
        break
    if t[i] in c_res:
        if c_res[t[i]][1] > 0:
            c_res[t[i]][1] -= 1
            summ -= 1
    if i+len_s < len(t) and t[i+len_s] in c_res:
        if c_res[ t[i+len_s] ][1] < c_res[ t[i+len_s] ][0]:
            c_res[ t[i+len_s] ][1] += 1
            summ += 1
else:
    print(-1)

首先，我要提到的是链接到的Python代码非常糟糕。这样，我的意思是没有什么明确命名的。对于要完成的工作，这完全是挑衅的。我敢肯定，如果我说俄语或该页面上的任何内容，这将更清楚，但这不是我所说的。我知道Python编程与Swift编程具有不同的文化，因为Python经常为临时解决方案编写，但实际上应该重构，部分提取了命名良好的功能。这将使它变得更加可读性，并且可能会帮助您将其转化为Swift。我不会尝试在这里进行这些重构，但是一旦解决了错误，如果您想在任何形式的生产环境中使用它，就应该清理它。

正如您所承认的那样，您有很多错误。您询问错误的含义，但大概您想知道如何解决问题，因此我将同时解决这两个问题。错误始于此行：

    c_res[e] = [c_s[e], min( c_s[e], c_t[e] )]

第一个错误是无法为类型'string''''''[ny ny]'的值分配

这意味着您正在构建包含类型yyone的元素的数组并尝试将其分配给c_res [e]。 c_res是字典带有类型字符串的键和类型String的值。因此，假设e是字符串，它不是 - 在sec中更多地介绍 - 然后c_res [e]将具有类型值，<代码>字符串。

自然的问题是，为什么右侧是任何的数组。这取决于数组的定义不是合法的，并且编译器在上面窒息（基本上是其他错误的副产品）。原因是因为min期望其所有参数都是符合可比协议的单一类型，但是c_s [e]和c_s [e]是非法的...这是因为它们都是dictionary＆lt; cartinal int int＆gt;，因此他们期望contric> contrace> contract> contrace ，但是e不是字符。这是一个元组，（字符，int）。原因要在上一行上找到：

for e in c_s{

因为c_s is dictionary＆lt; contrac＆int＆gt;，其元素是包含targine的元素int。对于新手Swift的Python程序员来说，这可能令人惊讶。要迭代键，您必须指定这是您想要的，所以让我们纠正：

for e in c_s.keys {

通过固定的，以前的错误消失了，但是一个新问题已暴露出来。当您在swift中索引字典时，您会获得可选值，因为它可能是nil，如果该键，因此需要解开它。如果您确定c_s [e]也不是c_t [e]将是nil，您可以这样强制使用它们：

    c_res[e] = [c_s[e]!, min( c_s[e]!, c_t[e]! )]

但是你确定吗？当然，它们必须是不明显的。 我们需要使用可选的绑定或可选的均值处理可选的。

for (e, csValue) in c_s {
    let ctValue = c_t[e] ?? Int.max
    c_res[e] = [csValue, min(csValue, ctValue]
    summ += c_res[e][1]
}

因此，如果它是nil >。请注意， 代码>而不是c_s.keys，但是现在我们使用元组绑定将键仅分配给e，而将值分配给csvalue。这避免了c_s元素的可选交接。对于c_t [e]的值，min仍将返回csvalue，这似乎是意图。

但是我们再次暴露了另一个问题。现在，编译器抱怨我们无法分配array＆lt; c_res [e]，它预计为string> String ...在Swift中，字符串不是array＆lt; int＆gt;。我不确定为什么将C_RES定义为类型String的值时，当代码放入int的数组时...重新定义C_RES。

var c_res = [String: [Int]]()
var summ  = 0
for (e, csValue) in c_s {
    let ctValue = c_t[e] ?? Int.max
    c_res[e] = [csValue, min(csValue, ctValue)]
    summ += c_res[e][1]

用一个涅rv词来解释“嘿！等等！有一个新的抱怨！”具体来说，e是type 字符，但是c_res is dictionary＆lt; string，array＆lt＆lt; int＆gt;＆gt;＆gt;，所以让我们只制作c_res a 字典＆lt; cartem，array＆lt; int＆gt;＆gt;而不是。

var c_res = [Character: [Int]]()
var summ  = 0
for (e, csValue) in c_s {
    let ctValue = c_t[e] ?? Int.max
    c_res[e] = [csValue, min(csValue, ctValue)]
    summ += c_res[e][1]
}

耶！现在，我们已经解决了开始的行上的所有错误...但是现在下一行中有一个：可选类型的值'[int]？'必须解开包装以参考包装基本类型的成员“下标” [int]'

再次，这是因为当我们将dictionary索引时，我们的键键 /代码>可能不存在。但是，我们只是在调用min的电话中计算了要添加到summ的值，所以让我们保存下来并在此处重复使用它。

var c_res = [Character: [Int]]()
var summ  = 0
for (e, csValue) in c_s {
    let ctValue = c_t[e] ?? Int.max
    let minC = min(csValue, ctValue)
    c_res[e] = [csValue, minC]
    summ += minC
}

现在，我们终于在第一个循环中没有错误。剩余的错误在嵌套环中。

对于初学者，代码使用=来测试平等。与C家族中的所有语言一样，Swift将==用作平等操作员。我认为在几个地方需要的变化非常简单，因此我不会证明这种迭代。一旦修复了这些问题，我们就会在Swift中获得我最喜欢的（不是）错误：表达式类型是模棱两可的，而没有更多上下文在此行上：

        if t[i] == c_res[j] {

这些模棱两可的错误可能意味着一些事情之一。主要原因是因为表达式的元素匹配了几个定义，并且编译器没有办法弄清楚应该使用哪个定义。这种风味通常伴随着可能的比赛。当多个类型检查失败以编译器无法给出更明显的错误方式时，似乎也会发生这种情况。我认为这是这里发生的版本。此问题的来源返回到外部循环

for i in 0..<((t.count-s.count)+1)  {

，该循环使循环变量，i，为类型，int，与使用i结合使用。要索引t，即String。问题在于，您不能用int将String索引。您必须使用string.index。原因归结为字符串由Unicode字符组成并在内部使用UTF-8，这意味着其字符的长度不同。用int索引与array的元素相同的方式将需要O（ n ）复杂性，但将其索引到一个字符串有望具有O（1）复杂性。 String.Index通过使用String index（后面：）来计算其他索引的索引。基本上将索引到字符串是一种痛苦，因此在大多数情况下，Swift程序员做其他事情，通常依赖于许多方法String支持操作。当我写这篇文章时，我还没有汇总代码应该做的事情，这使得在这里很难弄清楚string方法可能会有所帮助，所以让我们只需转换<代码> t to array [farne]，然后我们可以使用整数将其索引到其中：

var t = [Character](readLine()!)

不过，它仍然给出模棱两可的表达错误，因此我查看了Python代码中的等效行。这揭示了翻译中的逻辑错误。这是Python：

    if t[i] in c_res:
        if c_res[t[i]][1] > 0:
            c_res[t[i]][1] -= 1
            summ -= 1

没有循环。看起来循环被引入模拟检查，以查看t [i]是否在c_res中，这是一种方法，但这是错误的。 Swift可以更简洁地做到这一点：

    if c_res.keys.contains(t[i]) {
        if c_res[t[i]][1] > 0 {
            c_res[t[i]][1] -= 1
            summ -= 1
        }
    }

但是我们可以使用可选的绑定来进一步清洁它：

    let tChar = t[i]
    if let cResValue = c_res[tChar] {
        if cResValue[1] > 0 {
            c_res[tChar][1] -= 1
            summ -= 1
        }
    }

但是，我们再次将索引到字典返回需要在行上取消包装的可选式的问题，

            c_res[tChar][1] -= 1

幸运的是，我们刚刚确保将c_res [tchar]绑定到cresvalue时，我们需要再次索引的唯一原因是，因为我们需要更新字典值...这是一个很好的使用力 - unwrap：

    let tChar = t[i]
    if let cResValue = c_res[tChar] {
        if cResValue[1] > 0 {
            c_res[tChar]![1] -= 1
            summ -= 1
        }
    }

最后一个循环似乎也是测试c_res中存在的结果，并且循环变量甚至都没有使用。这是原始的python：

    if i+len_s < len(t) and t[i+len_s] in c_res:
        if c_res[ t[i+len_s] ][1] < c_res[ t[i+len_s] ][0]:
            c_res[ t[i+len_s] ][1] += 1
            summ += 1

我们可以在此处使用可选的绑定与comma-if语法和另一种力 - 纳普。

    tChar = t[i + len_s]
    if i+len_s < t.count, let cResValue = c_res[tChar] {
        if cResValue[1] < cResValue[0] {
            c_res[tChar]![1] += 1
            summ += 1
        }
    }

当然，由于我们使用新值重新使用tchar，因此必须从let更改为var。

现在一切都编译了。它肯定需要重构，但是这里完全是：

import Foundation

var t = [Character](readLine()!)
var s = readLine()!
var len_s = s.count
var t_lis = Set(t)
let character:[Character] = Array(s)
var c_s:[Character: Int] = Dictionary(uniqueKeysWithValues: zip(character, Array(repeating: 1, count: character.count)))
let character2:[Character] = Array(t_lis)
var c_t:[Character: Int] = Dictionary(uniqueKeysWithValues: zip(character2, Array(repeating: 1, count: character2.count)))

var c_res = [Character: [Int]]()
var summ  = 0
for (e, csValue) in c_s {
    let ctValue = c_t[e] ?? Int.max
    let minC = min(csValue, ctValue)
    c_res[e] = [csValue, minC]
    summ += minC
}

for i in 0..<((t.count-s.count)+1)  {
    if summ == len_s-1 {
        print(i)
        break
    }
    
    var tChar = t[i]
    if let cResValue = c_res[tChar] {
        if cResValue[1] > 0 {
            c_res[tChar]![1] -= 1
            summ -= 1
        }
    }

    tChar = t[i + len_s]
    if i+len_s < t.count, let cResValue = c_res[tChar] {
        if cResValue[1] < cResValue[0] {
            c_res[tChar]![1] += 1
            summ += 1
        }
    }
}

如果所有这些让您想知道为什么有人会使用这种挑剔的语言，那么有两件事要考虑。首先是，最初以SWIFT编写代码，甚至从另一种强烈键入的语言翻译时，您不会遇到太多错误。从python等无打字语言中涵盖的是一个问题，因为除了细微的其他差异之外，您还必须将其固定在某种混凝土类型中的过于灵活的数据视图 - 并不总是很明显。另一件事是，强烈键入的语言使您能够尽早捕获大量的错误……因为类型系统甚至不允许它们编译。