在完全嵌套的for循环中返回值

Question

I want nested loops to test whether all elements match the condition and then to return True. Example:

There's a given text file: file.txt, which includes lines of this pattern:

aaa:bb3:3

fff:cc3:4

Letters, colon, alphanumeric, colon, integer, newline.

Generally, I want to test whether all lines matches this pattern. However, in this function I would like to check whether the first column includes only letters.

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

However, the function returns False even if all characters in the first column are letters. I would like to ask you for the explanation, too.

Answer 1

Your code evaluates the empty line after your code - hence False :

Your file contains a newline after its last line, hence your code checks the line after your last data which does not fullfill your test- that is why you get False no matter the input:

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

You can fix it if you "spezial treat" empty lines if they occur at the end. If you have an empty line in between filled ones you return False as well:

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"))

Output:

True

---

If you use

# 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
""") 

or

# 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


""") 

you get: False

Answer 2

Colonoscopy

1. ASCII, and UNICODE, both define character 0x3A as COLON . This character looks like two dots, one over the other: :

2. ASCII, and UNICODE, both define character 0x3B as SEMICOLON . This character looks like a dot over a comma: ;

You were consistent in your use of the colon in your example: fff:cc3:4 and you were consistent in your use of the word semicolon in your descriptive text: Letters, semicolon, alphanumeric, semicolon, integer, newline.

I'm going to assume you meant colon (':') since that is the character you typed. If not, you should change it to a semicolon (';') everywhere necessary.

Your Code

Here is your code, for reference:

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

Your Problem

The problem you asked about was the function always returning false. The example you gave included a blank line between the first example and the second. I would caution you to watch out for spaces or tabs in those blank lines. You can fix this by explicitly catching blank lines and skipping over them:

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

Some Other Problems

Now here are some other things you might not have noticed:

1. You provided a nice comment in your function. That should have been a docstring:

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

2. You import string in the middle of your function. Don't do that. Move the import up to the top of the module:

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

3. You opened the file with open() and never closed it. This is exactly why the with keyword was added to python:

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

4. You opened the file, read its entire contents into memory, then split it into lines discarding the newlines at the end. All so that you could split it by colons and ignore everything but the first field.

   It would have been simpler to just call readlines() on the file:

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

   It would have been even easier and even simpler to just iterate on the file directly:

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

5. It seems like you are building up towards checking the entire format you gave at the beginning. I suspect a regular expression would be (1) easier to write and maintain; (2) easier to understand later; and (3) faster to execute. Both now, for this simple case, and later when you have more rules in place:

    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. Your names are bad. Your function includes the names file , fi , i , j , and res . The only one that barely makes sense is file.

   Considering that you are asking people to read your code and help you find a problem, please, please use better names. If you just replaced those names with file (same), infile , line , ch , and result the code gets more readable. If you restructured the code using standard Python best practices, like with , it gets even more readable. (And has fewer bugs!)