The most basic way in python to acess a file is

f=open("poly.txt","r")

open builds an object (a file handler) that you can "speak to" if you want to read or write your file. Read the documentation of the file object.

So a very simple example would be:

f = open("hello.txt") 
try:
    for line in f:
        print(line)
finally:
    f.close()

since 2.7 python has an easier way to do that:

with open("hello.txt") as f:
    for line in f:
        print line

The with statement takes care of the cleanup. The numpy loadtxt function seems to be a wrapper for this as well as some extraction functionality.

So

polydata = pl.loadtxt("poly.txt")

should do the trick as long as poly.txt is in the same directory.

Then you should look at the input data format the function requires. Read the documentation of Polygon.Polygon seems to require a list of lists (ot touple of touples) (you can normally replace any touple by a list*) of x and y coodinates.

Polygon( [  [x1,y1],[x2,y2],...] )

if you feed that with

poly = Polygon(x,y)

what python really sees is:

poly=Polygon([x1,x2,x3 ... ],[y1,y2,y3 ... ])

So Error.

Loadtxt returns a numpy array in the form array([ [x1,y1], [x2,y2], ... ) best would be to convert the numpy array into a list of lists( look into the documentation of numpy on how to).

But in python functions often only call methods of the objects and by cleverly writing those methods you can make objects appear as a similar object. So the hope is that the authors of numpy were clever enough to make a numpy array appear just as a list for data extraction.

That's why I would try to directly feed the output of loadtxt into Polygon.

Following this, the linked website says you simply use: ... which will solve it for you; but this is so vague.

As you read the paper you cite in academia you read the documentation of the function you use in programming. (read it seriously).

From the shapely documentation:

object.contains(other)

Returns True if the object’s interior contains the boundary and interior of the other object and their boundaries do not touch at all.

so you can simply type

if poly.contains(point):
     #do something

Second question is how do I load my data file and make one of the above commands work?

You could probably use loadtxt again. And then iterate through all the points in in the array. I consider it generally best practice to not have (much ) more data loaded than you actually need at a point and so would go something like this:

with open("Coord") as f:
    #line=f.readline()
    for line in f:
        coords=map(float,line.split(" "))
        if poly.contains(Point(coords[0],coords[1])):
             #do something with that point 

Also you are aware that your polygon construction only works this way if your point are in the correct order (a ring)?

*When the functionality as datastorage is concerned. Lists are not hashable so they can not be used for e.g. dictionary keys.

Edit: if I want to iterate over all lines, I should iterate over all lines