++ is not an operator. It is two + operators. The + operator is the identity operator, which does nothing. (Clarification: the + and - unary operators only work on numbers, but I presume that you wouldn't expect a hypothetical ++ operator to work on strings.)

++count

Parses as

+(+count)

Which translates to

count

You have to use the slightly longer += operator to do what you want to do:

count += 1

I suspect the ++ and -- operators were left out for consistency and simplicity. I don't know the exact argument Guido van Rossum gave for the decision, but I can imagine a few arguments:

• Simpler parsing. Technically, parsing ++count is ambiguous, as it could be +, +, count (two unary + operators) just as easily as it could be ++, count (one unary ++ operator). It's not a significant syntactic ambiguity, but it does exist.
• Simpler language. ++ is nothing more than a synonym for += 1. It was a shorthand invented because C compilers were stupid and didn't know how to optimize a += 1 into the inc instruction most computers have. In this day of optimizing compilers and bytecode interpreted languages, adding operators to a language to allow programmers to optimize their code is usually frowned upon, especially in a language like Python that is designed to be consistent and readable.
• Confusing side-effects. One common newbie error in languages with ++ operators is mixing up the differences (both in precedence and in return value) between the pre- and post-increment/decrement operators, and Python likes to eliminate language "gotcha"-s. The precedence issues of pre-/post-increment in C are pretty hairy, and incredibly easy to mess up.

Its because you've re-defined the count variable or reset it to 1 for each loop again. I'm not into python but your code doesn't make sense since everytime the count variable is first set to 1 and then incremented. I'd simply suggest the following.

import os

cur = dir(os)
count = 1
for i in cur:
    count += 1
    print(count,i)

Python doesn't support ++, but you can do:

number += 1

Floating point numbers are not precise. The more you handle them, the more error they can accumulate. To have numbers you want, the best way is to keep things integral for as long as possible:

def number():
    b = 1
    while True:
        yield b / 10.0
        b += 1

If I understand correctly, you could just create a helper dataframe of the rows you want duplicated, then increment the Week number on that helper dataframe, then concatenate to your original:

helper = pd.concat([df.loc[df.Course == 'Prison']]*2)
helper['Week'] += helper.reset_index().index+1

df = pd.concat((df,helper)).sort_values('ID')

>>> df
   ID    Name  Week      Course  Hours
0   1  John A  1922   Bike Tech    5.5
1   2  John B  1922   Auto Tech    3.2
2   3  John C  1922      Prison    3.5
2   3  John C  1923      Prison    3.5
2   3  John C  1924      Prison    3.5
3   4  John D  1922        Comp    6.5
4   5  John E  1922   Awareness    7.0
5   6  John F  1922   First Aid    7.2
6   7  John G  1922  BasketBall    2.5
7   8  John H  1922        Tech    5.4

Untested, but some variation of this will work ;-)

n = len(card_task_e)
for i in range(1, n, 2):
    base = card_task_e[i]
    for j in range(i+1, n, 2):
        if base > card_task_e[j]:
            counte += 1
            ol_task_e.append(base)

for the code,

for i in range(0,10):
   if i == 3:
       i = i + 1
       continue
   print(i)

the output is going to be,

0
1
2
4
5
6
7
8
9

Breaking down the code,

for i in range(0, 10)

for loop runs for i=0 to i=9, each time initializing i with the value 0 to 9.

if i == 3:
 i = i + 1
 continue
print(i)

when i = 3, above condition executes, does the operation i=i+1 and then continue, which looks to be confusing you, so what continue does is it will jump the execution to start the next iteration without executing the code after it in the loop, i.e. print(i) would not be executed.

This means that for every iteration of i the loop will print i, but when i = 3 the if condition executes and continue is executed, leading to start the loop for next iteration i.e. i=4, hence the 3 is not printed.

Use emumerate instead .

for counter,line in enumerate(train_instances):
    a,b = line.split(":")

Don't increment anything in the loop or reset counter at all

You need to define the negative variable before stepping into the loop:

negative = 0
for line in neg_file:
    # no changes

The way you are proceeding, it is "created" every single loop.

A list comprehension will do the trick:

>>> t = [(('d',0),('g',0)),(('d',0),('d',1)),(('i',0),('g',0))] 

>>> print([tuple((a, b+1) for a, b in group) for group in t])

   [[('d', 1), ('g', 1)], [('d', 1), ('d', 2)], [('i', 1), ('g', 1)]]

Here is a possible solution (s is your string):

for j in range(len(s) - 1):
    print(s[j:j + 2])

Another one:

for c1, c2 in zip(s[:-1], s[1:]):
    print(c1 + c2)

It seems that you want to use step parameter of range function. From documentation:

range(start, stop[, step]) This is a versatile function to create lists containing arithmetic progressions. It is most often used in for loops. The arguments must be plain integers. If the step argument is omitted, it defaults to 1. If the start argument is omitted, it defaults to 0. The full form returns a list of plain integers [start, start + step, start + 2 * step, ...]. If step is positive, the last element is the largest start + i * step less than stop; if step is negative, the last element is the smallest start + i * step greater than stop. step must not be zero (or else ValueError is raised). Example:

 >>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 >>> range(1, 11) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 >>> range(0, 30, 5) [0, 5, 10, 15, 20, 25]
 >>> range(0, 10, 3) [0, 3, 6, 9]
 >>> range(0, -10, -1) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
 >>> range(0) []
 >>> range(1, 0) []

In your case to get [0,2,4] you can use:

range(0,6,2)

OR in your case when is a var:

idx = None
for i in range(len(str1)):
    if idx and i < idx:
        continue
    for j in range(len(str2)):
        if str1[i+j] != str2[j]:
            break
    else:
        idx = i+j

Maybe loop it a bit different like this?

for item in pritunlServResponse:
    srv_id = item['id']
    name = item['name']

This way you wouldn't have to create these in the first place

Name = [y['name'] for y in pritunlServResponse]
Server_id = [x['id'] for x in pritunlServResponse]

for i in [float(j) / 100 for j in range(0, 100, 1)]:
    print i

Because x is a local (all function arguments are), not a global, and integers are not mutable.

So x += 1 is the same as x = x + 1, producing a new integer object, and x is rebound to that.

You can mark x a global in the function:

def add_one():
    global x
    x += 1

There is no point in passing in x as an argument here.

i is reassigned at every iteration; that's how the for loop works. If you want to skip every second number (i.e. iterate in steps of 2), you'll need to do this:

for i in range(0, 10, 2):
    print(i, end="")

That third parameter of the range function, called step, just determines what i is incremented by in each iteration.

You could convert the string to an int and use something like

self.seq = '%010d' % (int(self.seq) + 1)
return self.seq

If you didn't need self.seq to be a string you could do

def __init__(self) :
    self.seq = 0

def getNextSeqNo(self) :
    self.seq += 1
    return '%010d' % self.seq