在非常嵌套的 for 循环中返回值

Question

我想要嵌套循环来测试是否所有元素都符合条件，然后返回 True。示例：

有一个给定的文本文件：file.txt，其中包含这种模式的行：

aaa:bb3:3

fff:cc3:4

字母、冒号、字母数字、冒号、整数、换行符。

一般来说，我想测试是否所有的行都匹配这个模式。但是，在这个函数中，我想检查第一列是否只包含字母。

def opener(file):
    #Opens a file and creates a list of lines
    fi=open(file).read().splitlines()
    import string
    res = True
    for i in fi:
        #Checks whether any characters in the first column is not a letter
        if any(j not in string.ascii_letters for j in i.split(':')[0]):
             res = False
        else:
            continue
    return res

但是，即使第一列中的所有字符都是字母，该函数也会返回 False。我也想请你解释一下。

Answer 1

您的代码评估代码后的空行 - 因此 False ：

您的文件在其最后一行之后包含一个换行符，因此您的代码会检查最后一个数据之后的行，这未完成您的测试 - 这就是为什么无论输入如何都会得到 False：

aaa:bb3:3
fff:cc3:4
                    empty line that does not start with only letters

如果空行出现在末尾，您可以“特别处理”空行来修复它。如果您在填充的行之间有一个空行，您也可以返回 False：

with open("t.txt","w") as f:
    f.write("""aaa:bb3:3
fff:cc3:4
""") 

import string 
def opener(file):
    letters = string.ascii_letters
    # Opens a file and creates a list of lines
    with open(file) as fi:
        res = True
        empty_line_found = False
        for i in fi:
            if i.strip(): # only check line if not empty
                if empty_line_found:  # we had an empty line and now a filled line: error
                    return False
            #Checks whether any characters in the first column is not a letter
                if any(j not in letters for j in i.strip().split(':')[0]):
                    return False   # immediately exit - no need to test the rest of the file
            else:
                empty_line_found = True

    return res # or True


print (opener("t.txt"))

输出：

True

---

如果你使用

# example with a file that contains an empty line between data lines - NOT ok
with open("t.txt","w") as f:
    f.write("""aaa:bb3:3

fff:cc3:4
""") 

或

# example for file that contains empty line after data - which is ok
with open("t.txt","w") as f:
    f.write("""aaa:bb3:3
ff2f:cc3:4


""") 

你得到：False

Answer 2

结肠镜检查

1. ASCII 和 UNICODE 都将字符 0x3A 定义为 COLON。这个字符看起来像两个点，一个接一个：:

2. ASCII 和 UNICODE 都将字符 0x3B 定义为 SEMICOLON。这个字符看起来像一个逗号上的点：;

您在示例中对 分号 的使用始终如一：fff:cc3:4 并且您在描述性文本中对 分号 一词的使用始终如一：@ 987654324@

我假设您的意思是 冒号 (':')，因为那是您输入的字符。如果不是，您应该在任何必要的地方将其更改为分号 (';')。

您的代码

这是你的代码，供参考：

def opener(file):
    #Opens a file and creates a list of lines
    fi=open(file).read().splitlines()
    import string
    res = True
    for i in fi:
        #Checks whether any characters in the first column is not a letter
        if any(j not in string.ascii_letters for j in i.split(':')[0]):
             res = False
        else:
            continue
    return res

您的问题

你问的问题是函数总是返回 false。您提供的示例在第一个示例和第二个示例之间包含一个空行。我会提醒您注意这些空白行中的空格或制表符。您可以通过显式捕获空白行并跳过它们来解决此问题：

for i in fi:
    if i.isspace():
        # skip blank lines
        continue

其他一些问题

下面是您可能没有注意到的其他一些事情：

1. 您在函数中提供了很好的评论。那应该是一个文档字符串：

   def opener(file):
       """ Opens a file and creates a list of lines.
       """
   

2. 你 import string 在你的函数中间。不要那样做。移动导入 直到模块顶部：

   import string # at top of file
   
   def opener(file):   # Not at top of file
   

3. 您使用open() 打开了文件，但从未关闭过它。这正是为什么with关键字被添加到python：

   with open(file) as infile:
       fi = infile.read().splitlines()
   

4. 您打开文件，将其全部内容读入内存，然后将其拆分为行 最后丢弃换行符。所有这些都是为了你可以用冒号分割它并忽略 除了第一个字段之外的所有内容。

   在文件上调用readlines() 会更简单：

   with open(file) as infile:
       fi = infile.readlines()
   
       res = True
   
       for i in fi:
   

   直接迭代文件会更容易并且更简单：

   with open(file) as infile:
       res = True
       for i in infile:
   

5. 您似乎正在努力检查您在开始时提供的整个格式。我怀疑正则表达式会（1）更容易编写和维护； (2) 以后更容易理解； (3) 执行速度更快。现在，对于这个简单的案例，以及稍后当您有更多规则时：

   import logging
   import re
   
   bad_lines = 0
   for line in infile:
       if line.isspace():
           continue
       if re.match(valid_line, line):
           continue
       logging.warn(f"Bad line: {line}")
       bad_lines += 1
   return bad_lines == 0
   

6. 你的名字很糟糕。您的函数包括名称 file、fi、i、j 和 res。唯一没有意义的是file.

   考虑到您要求人们阅读您的代码并帮助您发现问题，请使用更好的名称。如果您只是将这些名称替换为 file（相同）、infile、line、ch 和 result，则代码的可读性会更高。如果您使用标准 Python 最佳实践（如 with）重构代码，它的可读性会更高。 （并且错误更少！）