Your end criteria must be formulated a little differently: run the loop while there are items and the bucket is positive. or is not the right operation here.

while unpaid_sales and bucket > 0:
    unpaid_sale = unpaid_sales.pop(0)
    #do stuff

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.

Your idiom is simple and good for most cases.

You must however keep in mind of 2 things:

1. You don't cap the retries. If the server is down for a long time, your script will get stuck.
2. You keep on generating requests even during downtimes. That can cause a large client and server load. I highly suggest using an exponential backoff strategy.

A quick search in google found the backoff library which allows you to do both:

@backoff.on_predicate(backoff.expo, lambda x: x == [], max_tries=10)
def getData(self):
     self.results = []
     ...
     return self.results

It checks the return value, and if it's an empty list, runs the function again with increasing delays until you reach 10 tries.

Lists don't have a len attribute. You have to call the len function with the list as an argument.

PeoplesNames = [];
while len(PeoplesNames) < 3:
    person = input('Enter your name: ')
    PeoplesNames.append(person);
print PeoplesNames

However, a better solution is to use a list comprehension:

peoples_names = [input('Enter your name:') for _ in range(3)]

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 []]

You can do:

while len(userdeck)>0:

or, you can write smartly as:

while userdeck:

This is because an empty list is considered as False, whereas a non empty list is considered as True. So, when userdeck is empty, while loop will assume it to be False case, so the loop will stop. This same concept can also be applied for if statements.

1. The problem is the list l gets smaller after calling l.remove(value), but subscript 'i' still try to index the original l.

2. Based on the above analysis, one solution is to keep l unchanged in the inner loop, the other is to keep the unseen i reduced along with l.

# Create new lists to keep `l` unchanged in the inner loop
def method1():
    l = [0, 1, 0, 0, 1, 1]
    removed= []
    while l:
      next_l = []
      [next_l.append(v) if v <= 0 else removed.append(i) for i, v in enumerate(l)]
      l = [x+1 for x in next_l]
    return removed

def method2():
    l = [0, 1, 0, 0, 1, 1]
    removed= []
    while l:
        num_del = 0  # record number of deletions in the inner loop
        for i in range(len(l)):
            if l[i-num_del]>0:
                l.remove(l[i-num_del])
                num_del += 1
                # store the index processing order
                removed.append(i)
            else:
                continue
        l = [x+1 for x in l]
    return removed


assert method1() == method2()
# output [1, 4, 5, 0, 1, 2]

But I guess you expect the result [1, 4, 5, 0, 2, 3], i.e., record the processing order with subscript in the original list. If so, try this:

l = [0, 1, 0, 0, 1, 1]
el = list(enumerate(l))
removed = []
bound = 0
while len(removed) != len(l):
    removed.extend(list(filter(lambda iv: iv[1] > bound, el)))
    el = list(filter(lambda iv: iv[1] <= bound, el))
    bound -= 1
removed, _ = zip(*removed)

Loops and conditionals implicitly use bool on all their conditions. The procedure is documented explicitly in the "Truth Value Testing" section of the docs. For a sequence like a list, this usually ends up being a check of the __len__ method.

bool works like this: first it tries the __bool__ method. If __bool__ is not implemented, it checks if __len__ is nonzero, and if that isn't possible, just returns True.

As with all magic method lookup, Python will only look at the class, never the instance (see Special method lookup). If your question is about how to change the behavior, you will need to subclass. Assigning a single replacement method to an instance dictionary won't work at all.