Home>

### bug questions in python list replacement

Genetic algorithm design (super beginner)

[Caution] I am a beginner for about a week after programming.

It is written as genetic algorithm, but it is not exact and the content is appropriate.

[Overview] Language: Python
Randomly generate 10 lists with 20 numbers from 1 to 1
Determine the list that has 2, 0 most (father) and the list that has the second most (mother)
3, Aggregate elements of father and mother by index and make a list (samples)
4. Randomly extract elements for each index from samples and generate 10 new generations (newgene)
5, loop steps 2-4

The operation so far works without problems.

Problems i am experiencing

If i loop several times, all will be in the same list (all 0's will be the same), and the change will stop. Only in that case (newgene is 1st place in the same ratio) as a mutation, one place of father
Processing to change to a random number (list replacement).
At this time, even though only father is changed, the same change occurs for mother for some reason.
Therefore, mutation has not been realized.

Applicable source code
``````import random
# Create 10 lists kid with 20 random numbers from 0 to 9 and list them as kids
kid = []
kids = []
for _ in range (11):
kids.append (kid)
kid = []
for _ in range (20):
kid.append (random.randint (0, 9))
kids.pop (0)
loop = 1
# -------------------- Loop below -------------------------
# Within about 1000 times, it will be the first place in the same ratio, and the 58th line will not work
for _ in range (1000):
# Count kids' 0's and list them in each_0_counts
each_0_counts = []
for x in kids:
each_0_counts.append (x.count (0))
# Set max_score to 0
# Premax_score is the next highest number of 0
max_score = max (each_0_counts)
premax_score = 0
for x in each_0_counts:
if x == max_score:
continue
elif x&gt;premax_score:
premax_score = x
else:
pass
# Processing when the number of 0s is the same (1st place in the same ratio)
if premax_score == 0:
premax_score = max_score
else:
pass
# Get list number 1 and 2 and decide father and mother
father_index = each_0_counts.index (max_score)
mother_index = each_0_counts.index (premax_score)
father = kids [father_index]mother = kids [mother_index]
# Problem area
# If the same rate is 1st place, change part of father randomly to avoid stopping the change
# At this time, if you print and examine father and mother, it will change to mother for some reason
if premax_score == max_score:
father [random.randint (0, 19)] = random.randint (0, 9)
else:
pass
parents = []
parents.append (father)
parents.append (mother)
print ("\ nFather:" + str (father))
print ("Mother:" + str (mother))
# list parents elements in samples by index
sample = []
samples = []
for y in range (21):
samples.append (sample)
sample = []
for x in parents:
try:
sample.append (x [y])
except IndexError:
continue
samples.pop (0)
# Randomly add elements from sample to generate 10 new individuals (newgenes)
newgenes = []
for _ in range (10):
newgenes.append ([])
xx = -1
xy = 0
for _ in range (20):
xx + = 1
xy = 0
for _ in range (10):
try:
xy + = 1
except IndexError:
continue
print ("No." + str (loop) + "Generation")
for x in newgenes:
print (str (x))
loop + = 1
kids = newgenes``````
Tried

・ I think that there is a problem with father's list replacement, and replace part of the list with father itself instead of replacement. When I tried assigning a string or an unrelated list, mother was not affected.
In other words, only when trying to replace part of father, there is a bug that mother is also changed.
The cause is unknown.

Supplemental information (FW/tool version etc.)

PC: Mac
Editor: Atom

Part-time reproduction when you reach first place.

``````max_score = max (each_0_counts)
premax_score = 0
for x in each_0_counts:
if x == max_score:
continue
elif x>premax_score:
premax_score = x
else:
pass
# Processing when the number of 0s is the same (1st place in the same ratio)
if premax_score == 0:
``````father = kids [father_index]