从python文件读取

Question

I have a text file that got some antonyms in the format:

able || unable
unable || able
abaxial || adaxial
adaxial || abaxial

and I need to check if this word is antonyms of another or not.

What i did is a code like this:

def antonyms():
    f = open('antonyms.txt', 'r+')
    for line in f:
        a = line.split('||')
        x = a[0]
        y = a[1]
    return x, y

but what I have got is only the last pairs, then I tried to indent return a bit so I did

def antonyms():
    f = open('antonym_adjectives.txt', 'r+')
    for line in f:
        a = line.split('||')
        x = a[0]
        y = a[1]
        return x, y

But again I got first pairs only

How can I get all of the pairs?

and how can I do something like:

>>> antonyms(x, y)

to tell me if they are True or False?

Answer 1

Your problem is that with return you are getting out of the function.

Instead, of x = a[0] and y = a[1] , append those values to an array, and the return that array.

the_array = []
for line in f:
    a = line.split('||')
    the_array.append((a[0],a[1]))
return the_array

Answer 2

You could use yield:

def antonyms():
    f = open('antonyms.txt', 'r+')
    for line in f:
        a = line.split('||')
        x = a[0]
        y = a[1]
        yield x, y

for a,b in antonyms():
     # rest of code here

By the way, you can assign directly to x and y:

x,y = line.split('||')

A simple check if a and b are antonyms could be:

(a == 'un' + b) or (b == 'un' + a)

Answer 3

It would make more sense to write a function that gets the antonym of a given word:

def antonym(word):
    with open('antonym_adjectives.txt', 'r+') as f:
        for line in f:
            a, b = line.split('||')
            a = a.strip()
            b = b.strip()
            if a == word:
                return b
            if b == word:
                return a

You can then write antonym(x) == y to check if x and y are antonyms. (However this assumes each word has a single unique antonym).

This reads the file from the beginning each time. If your list of antonyms is manageable in size it might make more sense to read it in to memory as an array or dictionary.

If you can't assume that each word has a single unique antonym, you could turn this into a generator that will return all the antonyms for a given word.

def antonym(word):
    with open('antonym_adjectives.txt', 'r+') as f:
        for line in f:
            a, b = line.split('||')
            a = a.strip()
            b = b.strip()
            if a == word:
                yield b
            if b == word:
                yield a

Then y in antonyms(x) will tell you whether x and y are antonyms, and list(antonyms(x)) will give you the list of all the antonyms of x .

Answer 4

Because no answer answers BOTH your questions:

Firstly: if you return, the program will stop there. So you want to yield your antonym so the whole function becomes a generator:

def antonyms():
    f = open('antonyms.txt', 'r+')
    for line in f:
        a = line.split(' || ') # Think you also need surrounding spaces here.
        x = a[0]
        y = a[1]
        yield x, y

To use this function to check for is_antonym(a,b) :

def is_antonym(a,b):
    for x,y in antonyms():
        if a == x and b == y:
            return True
    return False

Other answers have good tips too:
A good replacement for instance would be: [x,y] = line.split(' || ')

Answer 5

that is my code ..

def antonyms(first,second):
    f = open('text.txt', 'r')

    for line in f.readlines():
        lst = [s.strip() for s in line.split('||')]
        if lst and len(lst) == 2:
            x = lst[0]
            y = lst[1]
            if first == x and second == y:
                return True
    return False

Answer 6

I don't think list is a good data structure for this problem. After you've read all the antonym pairs into a list, you still have to search the whole list to find the antonym of a word. A dict would be more efficient.

antonym = {}
with open('antonym_adjectives.txt') as infile:
    for line in infile:
       x,y = line.split('||)
       antonym[x] = y
       antonym[y] = x

Now you can just look up an antonym in the dict:

try:
   opposite = antonym[word]
except KeyError:
   print("%s not found" %word)