In the for loop, you're overwriting data at every iteration with data = coords_data. If data is a list, then use data.append(coords_data) instead to add new data to it at each iteration. Note that you'll need to initialize it before the for loop with data = []

Essentially:

data = []
for grp_str in group_strings:
   data.append(self.point_dict[grp_str]['Coords'])

Because in each iteration of your for loop you are assigning the value of desc.split(";") to station so it holds the current value at each moment, when the for loops ends then the value that it holds is the last one, and then that's when you print it.

You aren't appending to a list; you are repeatedly redefining which single-element list a refers to.

a = []
for n in range(N):
    a.append(10 + n)

1. I think something got messed up when you copy pasted. Your code appears like it isn't properly indented, please check this first (You're referring to your iterators outside of the loop or this intentional?)

2. You're a bit vague about what you're actually trying to accomplish. What is the output data you want to get? What needs to be passed to the api?

3. When you post code it's best to put comments above logical blocks explaining what you're trying to accomplish with the code below (not what you're doing, eg. looping though list xy, but why you're doing what you're doing.) Nobody here has a clue about your project, so to save everybody time, explain what you're trying to do so we don't have to guess.

4. Looping through dataframes is almost always a bad idea, but we can get to that after my first three points are addressed.

So you write all you files into one, that's not gonna work

Try this

import os
url="someurl"
outputfile='./file.zip'

link=urllib.urlopen(url)
soup= bs4.BeautifulSoup(link,'lxml')

links=[]
for data in soup.find_all('div', class_='master_content-outer-container'):
    for a in data.find_all('a'):
        links.append(a.get('href'))


for i in links:
    request=urllib.urlopen(i)
    read=request.read()

    file_name = os.path.basename(i)
    output = open(file_name, "wb")
    output.write(read)
    output.close()

    zip_ref= zipfile.ZipFile(file_name,'r')
    zip_ref.extractall('./data/')
    zip_ref.close()

Option 2

import os

url="someurl"
outputfile='./file.zip'

link=urllib.urlopen(url)
soup= bs4.BeautifulSoup(link,'lxml')

def download_and_extract(link):
    request=urllib.urlopen(link)
    read=request.read()

    file_name = os.path.basename(link)
    output = open(file_name, "wb")
    output.write(read)
    output.close()

    zip_ref= zipfile.ZipFile(file_name,'r')
    zip_ref.extractall('./data/')
    zip_ref.close()

for data in soup.find_all('div', class_='master_content-outer-container'):
    for a in data.find_all('a'):
        download_and_extract(a.get('href'))

Because you're overwriting word in the loop, not really a good idea. You can try something like:

wordlist = ""
for word in wordStr:
    wordlist = "%s %s"%(wordlist,word.strip())
print wordlist[1:]

This is fairly primitive Python and I'm sure there's a more Pythonic way to do it with list comprehensions and all that new-fangled stuff :-) but I usually prefer readability where possible.

What this does is to maintain a list of the words in a separate string and then add each stripped word to the end of that list. The [1:] at the end is simply to get rid of the initial space that was added when the first word was tacked on to the end of the empty word list.

It will suffer eventually as the word count becomes substantial since tacking things on to the end of a string is less optimal than other data structures. However, even up to 10,000 words (with the print removed), it's still well under a second of execution time.

At 50,000 words it becomes noticeable, taking 3 seconds on my box. If you're going to be processing that sort of quantity, you would probably opt for a real list-based solution like (equivalent to above but with a different underlying data structure):

wordlist = []
for word in wordStr:
    wordlist.append (word.strip())
print wordlist

That takes about 0.22 seconds (without the print) to do my entire dictionary file, some 110,000 words.

You don't need range(len(list_)) for iterating over indeces only.

Usual for will do. You can also unpack list with *:

fields = [['a','b','c'],['x','y','z']]
len_ = len(fields)
for i in range(len_):
    driver.find_element_by_xpath("element").send_keys(*fields[i])

You could also iterate trhrough the values of the fields itself:

fields = [['a','b','c'],['x','y','z']]

for field in fields:
    driver.find_element_by_xpath("element").send_keys(*field)

As RedzMakersError said, you only check if the word is #, and only #.

You should try something like:

 if word.startswith('#'):
   hashtag_list.append(word)

As the name of the function says, it returns True if the string starts with #, False otherwise.

Official documentation: https://docs.python.org/3/library/stdtypes.html#str.startswith

First way, append() doesn't return anything, so its return value will be None.

Second way, nothing is "being returned", you are overwriting the value within a loop, then only inspecting the value of the entire df["Month_Name"] column after the final iteration, which by definition, will be the last value.

I think using loops is the wrong approach here, you should be using apply or map functions instead, but if you wanted a loop, I might suggest this

df["Month_Name"] = [calendar.month_abbr[i] for i in df["Month_Number"]]

So, what's happening here is that the dictionary you are trying to update is a runtime variable at this point, and every time it gets updated in the for loop, it is also updating the value of the item present in it so that the final output is the same where ever this variable is present. Considering values in both list and dict are not hardcoded values but dynamic in nature.

It can simply be fixed by creating an empty dict at every iteration. So it does not overwrite the same location in memory, and unique values are captured.

instances = []

for i in range(4):
    inst = {}
    print i
    inst['count'] = i
    instances.append(inst)
print instances

The initialization of total_mass_sum must be outside the for loop in order to prevent reseting of the output payload for each iteration and the append to total_mass_sum must be inside the for loop:

mass_list = [1969,100756]                     
total_mass_sum = []                           
for a in mass_list:                           
    mass_sum = 0                              
    while a >= 6:                             
        i = (int (a/3)-2)                     
        mass_sum = i+mass_sum                 
        a = i                                 
    total_mass_sum.append(mass_sum)          

print(total_mass_sum) # output: [966, 50346]                       

Yes it's an indentation issue: the print statement needs to be "inside" the for loop. As you have it, the print statement is executed just once, after the for, using the values of the variables name, hours, pay computed in the last pass through the loop.

Edit: Even more precisely, the print statement should be inside the if statement within the for loop. You don't want to print anything if a line was just blank, and certainly you don't want to print the previously line again (which you would, using values from the previous iteration).

This happens because in the expression:

dict((covar_type,GMM(n_components=num,
                covariance_type=covar_type, init_params='wmc',n_init=1, n_iter=10)) for covar_type in covs for num in num_comp)

You are using the same covar_type as key over all iterations, thus rewriting the same element.

If we write the code in a more readable way, this is what it's happening:

data = dict()
for covar_type in covs:
    for num in num_comp:
        # covar_type is the same for all iterations of this loop
        # hence only the last one "survives"
        data[covar_type] = GMM(...)

If you want to keep all the values you should use a list of values instead of a single value or change the key.

For the list of values:

data = dict()
for covar_type in covs:
    data[covar_type] = values = []
    for num in num_comp:
        values.append(GMM(...))

For different keys:

data = dict()
for covar_type in covs:
    for num in num_comp:
        data[(covar_type, num)] = GMM(...)