It's because you're actively changing the length of the list while you're looping it! Its a mistake I make too easily.

Try instead to append items to a new list rather than altering the original list, you'll run into problems otherwise, others may correct me though. Try instead to append items you want to a "new_list" etc. Try this:

new_list = []
for item in list:
    if item[0] != "#"
        new_list.append(item)

print(new_list)

Let me know if that helps you

Each time your first loop runs, it sets linelist to a new value, overwriting any old value. After that first loop runs, linelist will contain only the split result from the last line of the file. Every time you process one line of the file, you are throwing away whatever you did with the previous line.

If you want to build a list of all words in the dictionary file, you need to make a list and append to it on each iteration of your for line in infile loop.

Also, it doesn't make much sense to use split on each line if each line is just one word, since there will be no splitting to be done.

As stated in a comment, this is an easy fix. Simply move the else statement's return to outside of the loop.

def find(x):
    if x > 1:
        for i in range(2,x):
            if x % i == 0:
                return "its not a prime num"
        return "Its a prime num"


user = int(input("Enter your no: "))
print(find(user))

Simple answer: because your return statement is inside the for loop. So, probably just an indentation error.

But this code is, I must say, pretty un-Pythonic. You're doing lots of iterating through ranges, which should always be a red flag: in Python you usually want to iterate through an actual thing, not a specially-constructed range. In any case, since you're not even using the loop variable (process), you should consider if a for loop is the right structure at all.

Plus, as volcano points out in the comments, most of your setup code can be shortened significantly.

You set RABBITS and RABBIT_BIRTH_RATE at the beginning. Then, on every loop iteration, you set RABBITS_START to some formula involving these two numbers. You never change the value of RABBITS or RABBIT_BIRTH_RATE or FOXES or anything, so every time you run through the loop, you're just calculating the same thing again with the same numbers. You need to update the values of your variables on each iteration --- that is, set a new value for RABBITS, FOXES, etc.

There is both too much and not enough code there, to be able to find the "actual" problem. I would guess, though, that you are probably iterating over a list or array or collection and simultaneously removing things from it. That's a common question here on SO.

In general, you will see weird behavior like skipping over elements, or (in your case) having a list that should be empty show up as not empty.

In particular, I see you in one function doing this:

for element in monster.inventory:

In another function, you are doing this:

for object in objects:
    ...
    object.inventory.remove(self.owner)

I wonder if the monster.inventory list and the object.inventory list aren't the same at some point, which gives you a function accessing the list via an alias and removing elements, while you are trying to iterate over the list elsewhere.

Here's an example:

>>> inventory = [1,2,3]
>>> for item in inventory:
...     print(item)
...     inventory.remove(item)
...
1
3
>>> inventory
[2]

What happens is the iterator (for item in inventory) points to [1], the [1] gets .removed(), which means the iterator now points to [2], which is the new "first item" in the list. The loop finishes, the iterator advances, and now the iterator points to [3]. The [3] gets .removed(), the iterator tries to advance and reaches the end of the list, so it stops. You have now removed the [1] and the [3], and skipped over the [2].

Making a copy of the list, then iterating the copy, will ensure you iterate over every single item, while removing them from the official list.

You're calling return inside the loop because of where it is indented currently, so it gets executed after the very first iteration. Likely you want to move it outside the loop (the same indentation level as the for itself) so it gets called after the iteration is complete:

def computeBill(food):
    total = 0.0
    for item in food:
        total += prices[str(item)] + stock[str(item)]
        print total

    return total

Remove the return inside the loop, and put it outside. Otherwise you'd be exiting prematurely!

for i in d:
    U = 4 * diff * Nu / (i*i)
return U

There's another bug, though. What do you intend to do with the U inside the loop? you have to update it on each iteration, otherwise you'll only get the value of the last iteration.

EDIT:

Now that you've explained what you need in the comments (and this should have been in the question, to begin with), this is what you intended to do:

def heat_coeff(gas, Nu, d):
    mass = gas * 100
    diff = mass * 2
    return [4.0 * diff * Nu / (i*i) for i in d]

For example:

heat_coeff(10, 4, [1, 2, 3])
=> [32000.0, 8000.0, 3555.5555555555557]

You read through the file once with your first for loop, so there isn't anything left to read for the second loop. Seek back to the beginning of the file before starting the second loop:

fyle.seek(0)

Although I'd just cache the lines as a list, if possible:

with open('filename.txt', 'r') as handle:
    lines = list(handle)

Also, you can replace this:

if rows == 2:
    self.collisionLayer[rowcount][colcount] = False
else:
    self.collisionLayer[rowcount][colcount] = True

With:

self.collisionLayer[rowcount][colcount] = rows != 2

In pandas, DataFrame.iterrows() yields the index and the row. The index is something you control, and looking at your sample data you don't have an index that is densely-packed integers, but something else.

Try this code instead:

def dropNotIn(df):

    print(df.shape)

    removedlist = []
    droplist = []

    num_rows = 0
    for i, x in df.iterrows():
        num_rows += 1

    print(num_rows)
    print(len(df))

This counts the rows explicitly, instead of trying to use the index. If you really want to count rows during your operations, I'd suggest using the builtin function enumerate for this:

for num, (index, row) in enumerate(df.iterrows()):
   pass

However, I suspect you probably don't want to do that, because when you're doing things with a dataframe you want to vectorize them as much as possible.