Your line words = open("../WordsForGames.txt") does not read the file, it just opens it for reading or possibly writing if you add additional flags.

You need to read the line or lines using readlines(), for example, and then most likely split the words into a list and then randomly select one of the words. Something like this:

import random 

# get the first line if this is the one with the words words
lines = open("../WordsForGames.txt").readlines() 
line = lines[0] 

words = line.split() 
myword = random.choice(words)

Your for loop is iterating over every line in the file and indexing into that line. You should also take advantage of Python's context managers, which take care of opening and closing files for you. What you want is to load all the lines:

with open(infile) as f:
    contents_of_file = f.read()

Your second problem is that you aren't properly indexing into those lines with randrange. You want a range between 0 and the max number of lines:

lines = contents_of_file.splitlines()
line_number = random.randrange(0, len(lines))
return lines[line_number]

You also need to import the random module before this will run.

Your whole program would look like:

import random

def generate_the_word(infile):
    with open(infile) as f:
        contents_of_file = f.read()
    lines = contents_of_file.splitlines()
    line_number = random.randrange(0, len(lines))
    return lines[line_number]


def main():

    print(generate_the_word("Filename.txt"))


main()

You should also note that reading the file every time is inefficient; perhaps read it once and then pick lines from that. You could, for instance, read it in the main function and pass its already-read values to the generate_the_word function.

You don't need to read the whole file in at once nor use random.choice() if you use the reservoir-sampling algorithm. (This is the algorithm used in fortune on Unix!)

The algorithm is based on the idea that you select later samples based on a decreasing probability.

#!/usr/bin/python                                                               
import random                                                                   
from itertools import ifilter                                                   

_MAX_LEN = 6                                                                    

def goalword():                                                                 
    with open("words.txt") as fd:                                               
        for linenum, line in enumerate(ifilter(lambda x: len(x)-1 > _MAX_LEN, fd)):
            if random.uniform(0, linenum+1) <= 1:                                
                ret = line                                                      
    return ret.strip()                                                                  


print goalword()    

I based this on the Perl implementation from Perl Faq #5, which I'm more familiar with:

  srand;
  rand($.) < 1 && ($line = $_) while <>;

Since in Perl 0 <= rand(X) < X, whereas in Python, 0 <= random(0, X) <= X "depending on floating-point rounding in the equation a + (b-a) * random()", I've made my comparison inclusive (<=) to make sure the first line is always true.

If you look at Wikipedia's sample implementation, they just use randint(), so here is a modification to do that:

#!/usr/bin/python                                                               
from itertools import ifilter                                                   
from random import randint                                                      

_MAX_LEN = 6                                                                    

def goalword():                                                                 
    with open("words.txt") as fd:                                               
        for linenum, line in enumerate(ifilter(lambda x: len(x)-1 > _MAX_LEN, fd)):
            if randint(0, linenum) < 1:                                         
                ret = line                                                      
    return ret.strip()                                                                  


print goalword()           

Again, I make sure the first randint() is always true, otherwise a single line file might occasionally get no result.

For a reduce() implementation,

def goalword():                                                                
    with open("words.txt") as fd:                                               
        return reduce(lambda old, (i, new): new if randint(0, i) < 1 else old,
                      enumerate(ifilter(lambda x: len(x)-1 > _MAX_LEN, fd))).strip()

print goalword()  

Turns out, though, that reduce() isn't necessarily faster:

# for loop
print(timeit.timeit("goalword0()", setup="from __main__ import goalword0; import random; random.seed(42)", number=100, timer=time.clock))
# reduce
print(timeit.timeit("goalword1()", setup="from __main__ import goalword1; import random; random.seed(42)", number=100, timer=time.clock))

45.05 # for loop
49.17 # reduce

Note:

If you're picking more than one word from each execution, reading the whole file into a list will likely be more time efficient.

If you're just picking one word, however, this implementation is the most time and space efficient since you read the whole file once, but only retain one word in memory.

"In theory there is no difference between theory and practice. In practice there is."

I've tested this against a read-the-whole-file implementation:

def goalword():
    with open("words.txt") as fd:                                               
        words = filter(lambda x: len(x)-1 > _MAX_LEN, fd) 
    return random.choice(words).strip()                                         

It is significantly faster:

45.04 # For loop
7.14  # random.choice()

My word list is not insignificant:

$ curl -O https://raw.githubusercontent.com/dwyl/english-words/master/words.txt
$ wc -l words.txt 
466544 words.txt

My guess this is due to the overhead of the extra python opcode operations in the for loop vs filter being implemented in native C. i.e., we stay out of the interpreter for more of the work in the random.choice() implementation.

So, while not necessarily always faster, if you need to avoid loading the whole list into memory, reservoir sampling is what you want.

this is my first answer rsrs! Well, you can use a random lib for this:

def get_word(word_list):
   import random
   print(random.choice(word_list))

This function now get a randomly word in the list. It's that : )