python在字符串中留下一些单词

时间：2017-01-26 18:36:22

标签： python python-3.6

在我的高中课程中，我被分配了创建关键字密码的任务。然而，当我通过python可视化器运行它时，我仍然无法看到它做错了什么。

到目前为止，这是我的代码：

n = 0
l = 0
string = ""
message = input("enter your sentence: ")
message = (message.lower())
keyword = input("enter keyword: ")
keyword = (keyword.lower())
listkw = list(keyword)
def change(message,listkw,n,string,l):
    try:
        for letter in message:
            if letter == " ":
                string += " "
            else:
                temp = listkw[n]
                mtemp = ord(letter)
                mtemp -= 96
                ktemp = ord(temp)
                ktemp -= 96
                letterans = mtemp+ktemp
                if letterans >= 27:
                    letterans -= 26
                letterans += 96
                ans = chr(letterans)
                string += ans
                print (string)
                n+=1
                message = message[l:]
                l+=1
    except IndexError:
        n= 0
        change(message,listkw,n,string,l)
change(message,listkw,n,string,l)
print (string)

当我使用以下输入

运行它时 输入你的句子：computingisfun 输入关键字：gcse

它应该打印jrfubwbsnllkbq，因为它会在字母表中为每个字母添加它们并打印该字母。

例如：

change('a', list('b'), 0, "", 0)

打印出c，因为a = 1且b = 2且a + b = 3（即（c））

但它打印出jrfupqzn，这完全不是我的预期。

2 个答案:

答案 0 :(得分：0)

我知道你在高中时所以我更换了一些你不必要的代码，你会用经验做得更好;）

首先，您必须知道基于异常进行编程并不是一个好主意，如果添加条件并重新初始化n值，则更好，因此不需要例外; n = n + 1 if n + 1 < len(listkw) else 0

然后，你对变量的范围有一点问题，你在脚本的开头设置string = ""但是当调用函数string内部时，函数有不同的范围，所以当最后你print(string)有一个空字符串值，因此，你在函数中使用的值如n，l和string如果你在里面定义它会更好函数范围最后返回所需的值（计算（密码）字符串）

所以，代码是这样的：

阅读并初始化您需要的数据：

message = input("enter your sentence: ").lower()
keyword = input("enter keyword: ").lower()
listkw = list(keyword)

定义你的功能：

def change(message,listkw):
    n = l = 0
    string = ""
    for letter in message:
        if letter == " ":
            string += " "
        else:
            temp = listkw[n]
            mtemp = ord(letter) - 96
            ktemp = ord(temp) - 96
            letterans = mtemp + ktemp
            if letterans >= 27:
                letterans -= 26
            letterans += 96
            string += chr(letterans)
            message = message[l:]
            l+=1
            n = n + 1 if n + 1 < len(listkw) else 0
    return string

同时调用并打印返回值;）

print(change(message,listkw))

答案 1 :(得分：0)

你在这里所做的事情上遇到了很多问题。您在不要那样做的捆绑中混合递归，迭代和异常。

我想你可能已经有了一些关于该怎么做的想法，你开始沿着一条轨道开始，然后改为走另一条轨道。鉴于您是初学者，这并不奇怪。但是你应该知道，一致是一个好主意。您可以使用递归，迭代，切片或异常驱动来完成此操作。但是将它们结合起来却不理解为什么你这样做是一个问题。

设计

让我们将您的应用程序展开到您实际想要做的事情中。如果不编写任何代码，您将如何描述您正在采取的步骤？这就是我要说的：

对于邮件中的每个字母：

  • 从关键字
    • 获取下一个字母
  • 合并两个字母的数值
  • 如果信件是beyond Z(ebra)，请从A开始并继续计算
  • 当我们到达关键字中的最后一个字母时，循环回到开头

这给了我们一个关于我们如何写这个的提示。确实是最简单的方式，也是你已经部分完成的方式。

迭代

这是另一个指针 - 而不是从动态问题开始，让它变得非常静态：

 message = 'computing is awesome'

 for letter in message:
     print(letter)

您会看到这会打印出信息 - 每行一个字符。大！我们已经完成了问题的第一部分。现在下一步是从密钥中取出字母。好吧，让我们把钥匙放在那里。但是我们如何一次迭代两个字符串呢？如果我们搜索谷歌python iterate over two sequences，我的第一个结果就是How can I iterate through two lists in parallel?。不错。它告诉我们方便的花花公子zip功能。如果您想了解它，可以搜索python3 zip或在REPL中运行>>> help(zip)。

所以这是我们的代码：

message = 'computing is awesome'
keyword = 'gcse'

for letter, key in zip(message, keyword):
    print(letter, key)

现在如果我们运行这个......呃哦！

c g
o c
m s
p e

我们的其他字符串在哪里？在我们到达最短字符串结束后它停止了。如果我们查看zip的帮助，我们会看到：

  

继续，直到参数序列中的最短迭代用尽

所以它只会到最短的时间才会发生。那真是太可惜了。这意味着我们需要一个密钥和消息长度相同，对吧？或者是吗？如果我们的密钥更长而不是消息怎么办？希望到现在你知道你可以做这样的事情：

>>> 'ab'*10
'abababababababababab'

如果我们确保我们的密钥至少与我们的消息一样长，那就行了。因此，我们可以将关键时间乘以消息中的字母数。我的意思是，我们的方式比我们需要的更多，但这应该有效，对吗？我们试一试：

message = 'computing is awesome'
keyword = 'gcse'*len(message)

for letter, key in zip(message, keyword):
    print(letter, key)

甜！它奏效了！

现在让我们尝试添加ord值，让我们看看我们得到了什么：

for letter, key in zip(message, keyword):
    print(chr(ord(letter)+ord(key)))
哦，亲爱的。那些不是ASCII字母。正如您已经发现的那样，您需要从每个中减去96。事实证明，因为数学，你实际上可以从我们已经得到的总和中减去96 * 2. 

for letter, key in zip(message, keyword):
    if letter == ' ':
        print()
    else:
        new_code = (ord(letter)+ord(key)-96*2)
        print(chr(new_code+96))

但我们这里仍然有非字母字符。因此，如果我们确保将这一价值带回来：

for letter, key in zip(message, keyword):
    if letter == ' ':
        print()
    else:
        new_code = (ord(letter)+ord(key)-96*2)
        if new_code > 26:
            new_code -= 26
        print(chr(new_code+96))

现在我们很好。我们唯一要做的就是将我们的消息组合成一个字符串而不是将其打印出来，并将此代码粘贴到一个函数中。然后从用户那里获得我们的输入。我们还将把我们的密钥长度增加代码添加到函数中：

def change(message, keyword):
    if len(keyword) < len(message):
        keyword = keyword * len(message)
    result = ''
    for letter, key in zip(message, keyword):
        if letter == ' ':
            result += ' '
        else:
            new_code = (ord(letter)+ord(key)-96*2)
            if new_code > 26:
                new_code -= 26
            result += chr(new_code+96)
    return result

message = input('enter your sentence: ')
keyword = input('enter your keyword: ')
print(change(message, keyword))

递归

所以我们使用迭代工作了。递归怎么样？您在解决方案中使用递归肯定 。那么，让我们回到起点，弄清楚如何打印出我们的信息，一封信：

message = 'computing is awesome'

def change(message):
    if not message:
        return
    print(message[0])
    change(message[1:])

change(message)

有效。现在我们想要添加我们的密钥。事实证明，我们实际上可以做我们之前做过的事情 - 只需将其相乘：

def change(message, keyword):
    if not message:
        return

    if len(keyword) < len(message):
        keyword = keyword*len(message)

    print(message[0], keyword[0])
    change(message[1:], keyword[1:])

那简直太简单了。现在让我们打印出转换后的值：

def change(message, keyword):
    if not message:
        return
    if len(keyword) < len(message):
        keyword = keyword*len(message)
    new_code = (ord(message[0])+ord(keyword[0])-96*2)
    if new_code > 26:
        new_code -= 26
    print(chr(new_code+96))
    change(message[1:], keyword[1:])

我们再次需要处理空格字符：

def change(message, keyword):
    if not message:
        return

    if len(keyword) < len(message):
        keyword = keyword*len(message)

    if message[0] == ' ':
        print()
    else:
        new_code = (ord(message[0])+ord(keyword[0])-96*2)
        if new_code > 26:
            new_code -= 26
        print(chr(new_code+96))
    change(message[1:], keyword[1:])

现在唯一剩下的就是结合结果。在递归中，你通常会传递某种价值，我们会用我们的结果做到这一点：

def change(message, keyword, result=''):
    if not message:
        return result

    if len(keyword) < len(message):
        keyword = keyword*len(message)

    if message[0] == ' ':
        result += ' '
    else:
        new_code = (ord(message[0])+ord(keyword[0])-96*2)
        if new_code > 26:
            new_code -= 26
        result += chr(new_code+96)
    return change(message[1:], keyword[1:], result)

print(change(message, keyword))

切片

我们在递归方法中使用了一些切片。我们甚至可以在索引中传递，而不是切掉字符串的一部分。但现在我们要切片和骰子。它将与我们的递归解决方案非常相似：

def def（消息，关键字）：     如果len（关键字）＆lt; LEN（消息）：         keyword = keyword * len（message）

while message:
    print(message[0], keyword[0])
    message = message[1:]
    keyword = keyword[1:]

当你看到这一点时，要意识到你可以从我们的递归解决方案中输入代码并不是一件容易的事情：

while message:
    if message[0] == ' ':
        print()
    else:
        new_code = (ord(message[0])+ord(keyword[0])-96*2)
        if new_code > 26:
            new_code -= 26
        print(chr(new_code+96))
    message = message[1:]
    keyword = keyword[1:]

然后我们只将字符组合成结果：

def change(message, keyword):
    if len(keyword) < len(message):
        keyword = keyword*len(message)

    result = ''
    while message:
        if message[0] == ' ':
            result += ' '
        else:
            new_code = (ord(message[0])+ord(keyword[0])-96*2)
            if new_code > 26:
                new_code -= 26
            result += chr(new_code+96)
        message = message[1:]
        keyword = keyword[1:]
    return result

进一步阅读

你可以做一些更好的事情。而不是我们用密钥做的愚蠢乘法，itertools.cycle怎么样？

使用模除法而不是减法时会发生什么？

相关问题
最新问题