Question

我想在python中执行一个带2个字符串的函数，并比较位置。如果它们相等（'a'=='a'），它会附加一个True列表，如果它不是False。此外，如果列表中有更多位置，它也应返回False。

def g22(S1, S2):
    new = []
    if len(S1) > len(S2):
        for i in range(len(S1)):
            if S1[i] == S2[i]:
                new.append(True)
            elif S1[i] != S2[i]:
                new.append(False)
            else:
                new.append(False)
    elif len(S1) < len(S2):
         for i in range(len(S1)):
            if S1[i] == S2[i]:
                new.append(True)
            elif S1[i] != S2[i]:
                new.append(False)
            else:
                new.append(False)

    return new

这就是我想出来的，但除了认为这是错误的，它也是邋..的想法？感谢

Answer 1

您可以使用itertools.zip_longest：

from itertools import zip_longest

def agrees(s,t):
    return [x == y for x,y in zip_longest(s,t)]

例如，

>>> agrees("mathematical", "mythical")
[True, False, True, True, False, False, True, False, False, False, False, False]

请注意，{2}中的zip_longest为izip_longest。

Answer 2

两个基本建议：

整个

    if S1[i] == S2[i]:
        new.append(True)
    elif S1[i] != S2[i]:
        new.append(False)
    else:
        new.append(False)

可以替换为

        new.append(S1[i] == S2[i])

您可以使用if，而不是将两个长度与min(len(S1), len(S2))进行比较。这也将解决当前两个长度匹配时不处理案例的问题。

两个更高级的建议：

您可以使用list comprehension代替显式循环。
您可以使用zip()或map()同时迭代这两个列表。

Answer 3

试试这个：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static void printDouble(double val, int width)
{
    char *temp = malloc((width + 32) * sizeof(char));
    int len = 0;
    sprintf(temp, "%*.*g", width, width, val);
    len =strlen(temp);
    if (len > width) {
        char *dropped = temp + width;
        char *last = dropped - 1;
        char *expon = strchr(temp, 'E');
        if (!expon)
            expon = strchr(temp, 'e');
        if (expon) {
            last = temp + width - 1 - strlen(expon);
            dropped = last + 1 < expon ? last + 1 : NULL;
        }
        if (strchr(temp, '.')) {
            /* Round */
            if (dropped && *dropped >= '5' && *dropped <= '9') {
                while (*last == '9')
                    last--;
                (*last)++;
            }
            /* Remove trailing zeroes */
            while (*last == '0')
                last--;
        }
        if (expon) {
            while (*expon != '\0')
                *(++last) = *(expon++);
        }
        *(++last) = '\0';
    }
    printf("%*s\n", width, temp);
    free(temp);
}

Answer 4

不使用zip回答（根据OP的要求）：

def g22(S1, S2):

    str_max = S1 if len(S1) >= len(S2) else S2
    str_min = S1 if len(S1) < len(S2) else S2

    new = [False]*(len(str_max) - len(str_min))
    new = [str_min[i] == str_max[i] for i in range(len(str_min))] + new
    return new

希望range可以使用！

Answer 5

虽然我确实喜欢John Coleman的answer的紧凑性，但您可能希望在核心Python中不使用外部库（无论出于何种原因或限制）这样做。

如果是这样，接近它的一种方法是编写一个泛型函数，比较两个列表中相同索引位置的元素，捕获IndexError（当迭代两个不等长度字符串的字符时）并分配在那种情况下，比较为 False ：

def compareLists(argListA, argListB):

    size = max(len(argListA), len(argListB))

    result = []

    for i in range(size):

        try:
            comp = argListA[i] == argListB[i]
        except IndexError:
            comp = False

        result.append(comp)

    return result

然后您的用法可能类似于：

aStr = "Color"
bStr = "Colour"

#convert the strings into lists of chars

aList = []
aList.extend(aStr)

bList = []
bList.extend(bStr)

comp = compareLists(aList, bList)

print(comp)

打印：

[真，真，真，真，假，假]

Answer 6

所以这是我使用所有答案的一部分提出的代码

def g22(S1, S2):
    new = []
    if len(S1) >= len(S2):
        rest = [False] * (len(S1) - len(S2))
        for i in range(len(S2)):
            new.append(S1[i] == S2[i])
    elif len(S1) < len(S2):
        rest = [False] * (len(S2) - len(S1))
        for i in range(len(S1)):
            new.append(S1[i] == S2[i])
    return new + rest

返回：

g22('casa', 'passa')
[False, True, True, False, False]

谢谢大家：）

编辑：我觉得有点蠢，我们不能使用简单的内置工具，可以将其减少到4或5行但是很好。

Python - 比较字符串和返回布尔值，如果它们相等

6 个答案: