Project Euler problem 26 in Python
Boosting time performance:

Starting with minor naming issues:
maxi is better named as max_len (as stated in comment). maxi_d is renamed to max_d.
It's good to move the processing into a separate function, called like calc_longest_recur_cycle.

The main time-performance hits in your implementation is caused by quotient list and its expensive list operations:


quotient.append
quotient.index
cur_value not in quotient


According to that fact that quotient and len_recur are reset on each outer for loop iteration and on the level of while loop the fragment

len_recur += 1
quotient.append(cur_value)


tells that cur_value is appended synchronously with incrementing len_recur i.e. the cur_value will get the position equal to len_recur. That means that, on this level, cur_value can be mapped to its position contained in len_recur.Thus, quotient is initiated as dictionary (instead of list): quotient = {} or even quotient = {0: 0} as AJNeufeld suggested to eliminate cur_value evaluation on the while loop condition. 



The construction:

while cur_value not in quotient:
    if not cur_value:  # If the value is not recurring:
        break


is essentially a verbose equivalent to:

while cur_value and cur_value not in quotient:




List indexing 

len_recur -= quotient.index(cur_value) + 1 


is now efficiently replaced with dict indexing (where values are positions)

len_recur -= quotient[cur_value]




Now, with quotient as dict, we have O(1) complexity for membership check (cur_value not in quotient) and indexing operation (len_recur -= quotient[cur_value])

The final version:

LIMIT = 5000

def calc_longest_recur_cycle():
    max_len = 0   # The maximum length
    max_d = 1     # The 'd' that has maximum length

    for d in range(1, LIMIT):
        quotient = {0: 0}  # Stores the decimal quotient
        cur_value = 1      # Variable used to perform division as if by hand
        len_recur = 0      # Recurring length

        # Performing division as if by hand
        while cur_value not in quotient:  # while the value is not recurring
            len_recur += 1
            quotient[cur_value] = len_recur
            cur_value = (cur_value % d) * 10

        if not cur_value:
            continue

        # Remove number of values that do not recur
        len_recur -= quotient[cur_value]
        # quotient.clear()

        if len_recur &gt; max_len:
            max_len = len_recur
            max_d = d

    return max_d




What needs to be mentioned is that despite of its fast nature dict would take more space than list, but only at the time of one nominal loop iteration as it's reset and last quotient filled at the end will be garbage-collected on function exit.

Let's get to tests.
I've increased limit to LIMIT = 5000 to "turn up the heat" and have put the "old" implementation into separate function calc_recur_cycle_old for comparison.
As for resulting max_d value - both functions return the same result:

print(calc_recur_cycle_old())      # 4967
print(calc_longest_recur_cycle())  # 4967


And the most interesting time performance comparison:

from timeit import timeit

print(timeit('calc_recur_cycle_old()', 'from __main__ import calc_recur_cycle_old', number=1))
19.648109548998036

print(timeit('calc_longest_recur_cycle()', 'from __main__ import calc_longest_recur_cycle', number=1))
0.26926991600339534


The end ... )