Applying random luck scores to instances of people I'm trying to do a simulation on the role of luck in human achievement.
Here is what I intend to do with my code:

Create 20000 instances of people with randomly generated scores for skill, experience and hard-work(0 to 99), and a luck value(0 to 100).
Create a total score for each person, with 95% of the average of the skill, experience and hard-work, and 5% of their luck value.
Select the top 10 persons and record their luck value.
Iterate the procedure a specified amount of times and find the total average luck of all the people who came top ten in all of the iterations.

Please review the code and tell me if my code is correctly written for the above purpose. I'm skeptical about the pseudo-randomness random library interfering with the results.
import random
class candidate :
    def __init__(self):
        self.skill = random.uniform(0,99)
        self.exp = random.uniform(0,99)
        self.work = random.uniform(0,99)
        self.luck = random.uniform(0,100)
        self.total_score = ((self.skill+self.exp+self.work)/3)*.95+self.luck*0.05

candidate_list = []
candidate_selected_lucks = []
def select():
    for i in range (0,20000):
        candidate_list.append(candidate())
    for m in range(0,10):
        _max = 0.0
        for j in range (0,len(candidate_list)):
            if (candidate_list[j].total_score &gt; _max):
                _max = candidate_list[j].total_score
                index = j
        candidate_selected_lucks .append(candidate_list[index].luck)
        print(m,&quot;.&quot;,&quot; Score : &quot;, candidate_list[index].total_score, &quot; Luck : &quot;, candidate_list[index].luck,&quot;\n&quot;)
        candidate_list.pop(index)

def find_avg(candidate_selected_lucks):
    return sum(candidate_selected_lucks)/len(candidate_selected_lucks)

def simulate(N):
    for k in range(0,N):
        print (&quot;Iteration &quot;,str(k+1),&quot;. &quot;)
        select()
        candidate_list.clear()
    print (&quot;average luck is&quot;, find_avg(candidate_selected_lucks),&quot;\n&quot;)
        
count = int(input(&quot;Enter no of simulations\n&quot;))
simulate(count)
Python has an official style-guide, PEP8. It recommends using PascalCase for classes, so your class should be called Candidate. It also recommends using spaces after a , when passing multiple arguments to a function.
The creation of the candidates is as simple as this:
candidate_list = [Candidate() for _ in range(20000)]

Note that the starting index of range is 0 by default and that I used the customary variable name _ for the unused loop variable.
This also removes having to clear the candidates list, since it is being created anew every time you call the select function.
To get the candidate with the largest score, just use:
best_candidate = max(candidate_list, key=lambda c: c.total_score)

This does not allow you to easily remove them from the list of candidates, though. For this you can use enumerate:
index, candidate = max(enumerate(candidate_list), key=lambda t: t[1].total_score)


However, since you are running a not quite small numerical simulation, you might want to look into using numpy, which would greatly speed up the calculations. Instead of having a Candidate class, just create arrays. Generating random numbers in bulk is vastly faster than doing it one at a time as well:
import numpy as np

iterations = 100
candidates = 20000
top_ten_luck = []

for _ in range(iterations):
    scores = np.random.randint(0, 99, size=(candidates, 3))
    luck = np.random.randint(0, 100, size=candidates)
    total_score = 0.95 * scores.mean(axis=1) + 0.05 * luck
    top_ten = np.argpartition(-total_score, 10)[:10]
    top_ten_luck.extend(luck[top_ten])

print(np.mean(top_ten))

This runs in less than a second (132ms on my machine, to be exact). The for loop can also be vectorized, but at that point you might run into memory constraints.
Note that I used numpy.argpartition to get the indicies of the top ten candidates, in order to only partially sort the data as much as needed and not further. We need to use -total_score because it only gives you minimal values. This should be both faster than poping the maximum value ten times as well as completely sorting the list.