Because otherwise without it, if you either refer to it in the loop, it won't exist so you'll get an error. Or if you define it in the loop, you'll redefine it every iteration, destroying all the progress added to it from every previous iteration.

Based on the other answers, I think the cleanest solutions are

#Handles None return from get_list
for item in get_list() or []: 
    pass #do something

or the comprehension equiv

result = [item*item for item in get_list() or []]

The thing that I think you're missing here is that the StopIteration is what actually makes the for loop stop. This is why you can write custom iterators that work with Python's for loop transparently. It doesn't do any checking to see if the iterator is empty, and the for loop does not keep track of of the iterator's state. This is an effect of the iterator protocol, and was an intentional choice in the language design. You can read more about the iterator protocol on Python's docs site if you want to.

It also makes more sense if you think about the number of items in e.g. your list corresponding directly to the number of times your loop is executed.

-----------------------------------|
| No. of items | No. times executed|
------------------------------------
|      5       |         5         |
|      4       |         4         |
|      3       |         3         |
|      2       |         2         |
|      1       |         1         |
|      0       |         0         |
------------------------------------

If the for loop special-cased an empty iterable, this invariant would be lost.

It would also complicate the protocol on writing custom iterators, because you would have to have an extra method to signal to the for loop that your iterable is empty before the iteration began.

Here's a (stupid) example of a custom iterator that always acts like it's empty:

class EmptyIterator():
    def __iter__(self): return self
    def __next__(self): raise StopIteration

for blah in EmptyIterator():
    print('this is never reached')
try:
    next(EmptyIterator())
except StopIteration:
    print('Oh hi, I was empty so I raised this Exception for you.')

You'll have to stick with the if statement, but it can be simplified:

for x in my_list:
    doSomething()
if not my_list:
    print "my_list is empty"

since my_list is empty, the for loop never executes the loop portion, and an empty list is False in a boolean context.

Not my code, but if we look here, we see that time is used to create this "empty list".

% python -mtimeit  "l=[]"
10000000 loops, best of 3: 0.0711 usec per loop

% python -mtimeit  "l=list()"
1000000 loops, best of 3: 0.297 usec per loop

As far as actually iterating through the list, yes, this costs resources as well. The interpretter has to at least know that the list is empty, so it must go into the memory location to see that it is empty.

Your output=[] is inside your for loop. So at each iteration, its value is reinitialized, you should try again with output=[] before the for loop

Please do not use list as a variable name.

You can simply do if item['institutions'] it will only proceed if the list is non-empty

lst = [{'author_position': 'first',
  'author': {'id': 'https://openalex.org/A5012408034',
   'display_name': 'Vincent S. Tagliabracci',
   'orcid': 'https://orcid.org/0000-0002-9735-4678'},
  'institutions': [],
  'is_corresponding': False,
  'raw_affiliation_string': 'Molecular Biology',
  'raw_affiliation_strings': ['Molecular Biology']},
 {'author_position': 'last',
  'author': {'id': 'https://openalex.org/A5076217348',
   'display_name': 'Peter J. Roach',
   'orcid': None},
  'institutions': [{'id': 'https://openalex.org/I55769427',
    'display_name': 'Indiana University – Purdue University Indianapolis',
    'ror': 'https://ror.org/05gxnyn08',
    'country_code': 'US',
    'type': 'education'}],
  'is_corresponding': False,
  'raw_affiliation_string': 'Indiana-University Purdue-University Indianapolis',
  'raw_affiliation_strings': ['Indiana-University Purdue-University Indianapolis']}]

author_id = []
institution_id = []
for item in lst:
    author_id.append(item['author']['id'])
    if item['institutions']:
        institution_id.append(item['institutions'][0]['id'])

If you have lots of data to track in separate variables, don't rely on related variable names. What will your code do with all these variables after you have defined them? Use a dictionary:

datalists = dict()
for item in ['size', 'type']:
    datalists[item] = []

Addendum: By using a dictionary, you have one variable containing all list values (whatever they are) for your different labels. But perhaps (judging from your choice of names) the values in the corresponding list positions are meant to go together. E.g., perhaps size_list[0] is the size of the element with type type_list[0], etc.? In that case, a far better design would be to represent each element as a single tuple, dict or object of a custom class, and have a single list of all your objects.

Thing = namedtuple("Thing", ['size', 'type', 'floor'])
spoon = Thing(size=33, type='spoon', floor='green')

things = []
things.append(spoon)

Tuples (named or otherwise) cannot be modified, so this might not be what you need. If so, use a dictionary instead of a tuple, or write a simple class.

The problem is that you are modifying the list czynniki while iterating over it. Try this instead:

print n, ' = ',
for czynnik in sorted(set(czynniki)):
    if czynniki.count(czynnik)>1:
        print czynnik, '^', czynniki.count(czynnik), '*',
    else:
        print czynnik, '*',

Here you iterate over a separate list of only unique items of your list czynniki. This is achieved by casting the list to a set (an unsorted list of unique items) and then back to a sorted list.

If you want to get rid of that surplus * at the end, you could try this:

result_list = []
for czynnik in sorted(set(czynniki)):
    if czynniki.count(czynnik)>1:
        result_list.append(str(czynnik) + '^' + str(czynniki.count(czynnik)))
    else:
        result_list.append(str(czynnik))
print n, '=', ' * '.join(result_list)