How to use the statistics.stdev function in statistics

def one_cigar_test(self, cigar, dist_min, dist_max):
        qscores = []
        for _ in range(self.trials):
            q = self.model.get_qscore(cigar)
            q = badread.qscore_model.qscore_char_to_val(q)
            qscores.append(q)
        target_mean = (dist_min + dist_max) / 2
        target_stdev = math.sqrt(((dist_max - dist_min + 1) ** 2 - 1) / 12)
        self.assertAlmostEqual(statistics.mean(qscores), target_mean, delta=0.5)
        self.assertAlmostEqual(statistics.stdev(qscores), target_stdev, delta=0.5)

def setup_method(self, method):
        """Set up things to be run when tests are started."""
        self.hass = get_test_home_assistant()
        self.values = [17, 20, 15.2, 5, 3.8, 9.2, 6.7, 14, 6]
        self.count = len(self.values)
        self.min = min(self.values)
        self.max = max(self.values)
        self.total = sum(self.values)
        self.mean = round(sum(self.values) / len(self.values), 2)
        self.median = round(statistics.median(self.values), 2)
        self.deviation = round(statistics.stdev(self.values), 2)
        self.variance = round(statistics.variance(self.values), 2)
        self.change = round(self.values[-1] - self.values[0], 2)
        self.average_change = round(self.change / (len(self.values) - 1), 2)
        self.change_rate = round(self.average_change / (60 * (self.count - 1)), 2)

dice_score_bi, actual_bi, TP_bi, FN_bi, FP_bi = dice.get_score_bigrams(actual_terms)
        VV_TF_IDF_Tests.total_dice_bi += dice_score_bi

        VV_TF_IDF_Tests.dice_n.append(dice_score_n)
        VV_TF_IDF_Tests.dice_u.append(dice_score_u)
        VV_TF_IDF_Tests.dice_bi.append(dice_score_bi)

        if VV_TF_IDF_Tests.n_tests > 1:
            print(
                f" dice_n:  avg={statistics.mean(VV_TF_IDF_Tests.dice_n):0.3},"
                f" std={statistics.stdev(VV_TF_IDF_Tests.dice_n):0.3}")
            print(
                f" dice_u:  avg={statistics.mean(VV_TF_IDF_Tests.dice_u):0.3},"
                f" std={statistics.stdev(VV_TF_IDF_Tests.dice_u):0.3}")
            print(
                f" dice_bi: avg={statistics.mean(VV_TF_IDF_Tests.dice_bi):0.3},"
                f" std={statistics.stdev(VV_TF_IDF_Tests.dice_bi):0.3}")

        # shall we do try as well?
        VV_TF_IDF_Tests.n_tests += 1
        if dice_score_u < self.dice_threshold:
            tokenised_expected_terms_n = dice.expected_token_ngrams
            tokenised_expected_terms_u = dice.expected_token_unigrams
            tokenised_expected_terms_bi = dice.expected_token_bigrams

            self.fail(
                f'\n===================N-GRAMS============================\n'
                f'expected: {tokenised_expected_terms_n} \n'

f.write('Percent coverage:      {}\n'.format(song_err_pcdur))
                f.write('\n')

    with open(out_file, 'a') as f:
        f.write('\n')
        f.write('Aggregate evaluation results\n')
        f.write('------------------------------------\n')
        f.write('Avg start error:       {}\n'.format(mean(total_err_start)))
        f.write('Avg start error (abs): {}\n'.format(mean(map(abs, total_err_start))))
        f.write('Avg end error:         {}\n'.format(mean(total_err_end)))
        f.write('Avg end error (abs):   {}\n'.format(mean(map(abs, total_err_end))))

        total_err_start.extend(total_err_end)
        f.write('Avg total error:       {}\n'.format(mean(total_err_start)))
        f.write('Std total error:       {}\n'.format(stdev(total_err_start)))

        total_err_start = list(map(abs, total_err_start))
        f.write('Avg total error (abs): {}\n'.format(mean(total_err_start)))
        f.write('Std total error (abs): {}\n'.format(stdev(total_err_start)))

        f.write('Avg percent coverage:  {}\n'.format(mean(total_err_pcdur)))
        f.write('Std percent coverage:  {}\n'.format(stdev(total_err_pcdur)))
        f.write('\n')

        f.write('Miscellaneous errors ({})\n'.format(len(misc_err)))
        f.write('------------------------------------\n')
        for error in misc_err:
            f.write(error + '\n')

        f.write('\n')

def std_var_events_in_log(log: EventLog) -> int:
    """Returns the standard variation of the average number of events in any trace

    :return 3
    """
    return statistics.stdev([len(trace) for trace in log])

if idx and row[1] == rows[idx - 1][1]:
                            all_event_interdurations.append(float(row[0]) - float(rows[idx - 1][0]))

                    out_cat.append({
                        "subject": subject,
                        "behavior": behavior,
                        "modifiers": "",
                        "duration": NA,
                        "duration_mean": NA,
                        "duration_stdev": NA,
                        "number": len(rows),
                        "inter_duration_mean":
                        round(statistics.mean(all_event_interdurations), 3)
                        if len(all_event_interdurations) else NA,
                        "inter_duration_stdev":
                        round(statistics.stdev(all_event_interdurations), 3)
                        if len(all_event_interdurations) > 1 else NA
                    })

                if STATE in project_functions.event_type(behavior, ethogram):

                    cursor.execute(("SELECT occurence, observation FROM events "
                                    "WHERE subject = ? AND code = ? ORDER BY observation, occurence"),
                                   (subject, behavior))

                    rows = list(cursor.fetchall())
                    if not len(rows):
                        if not parameters[EXCLUDE_BEHAVIORS]:  # include behaviors without events
                            out.append({"subject": subject, "behavior": behavior,
                                        "modifiers": "", "duration": 0, "duration_mean": 0,
                                        "duration_stdev": "NA", "number": 0, "inter_duration_mean": "-",
                                        "inter_duration_stdev": "-"})

profile=args.profile))
        all_times[test_name].extend(times)
        all_rps[test_name].append(rps)

    if args.profile:
        profiler.dump_stats('out.prof')

    print()

    for test_name in sorted(all_rps):
        rps = all_rps[test_name]
        times = [t * 1000 for t in all_times[test_name]]

        rps_mean = mean(rps)
        times_mean = mean(times)
        times_stdev = stdev(times)
        times_median = median(times)
        print('Results for', test_name)
        print('RPS: {:d},\tmean: {:.3f} ms,'
              '\tstandard deviation {:.3f} ms\tmedian {:.3f} ms'
              .format(int(rps_mean),
                      times_mean,
                      times_stdev,
                      times_median))
    return 0

for e in bm.edges:
            if self.mode == 'LENGTH':
                length = e.calc_length()
                if length == 0: continue
                id0 = e.verts[0].index
                id1 = e.verts[1].index
                lap[id0] += weight[id1]/length - weight[id0]/length
                lap[id1] += weight[id0]/length - weight[id1]/length
            else:
                id0 = e.verts[0].index
                id1 = e.verts[1].index
                lap[id0] += weight[id1] - weight[id0]
                lap[id1] += weight[id0] - weight[id1]

        mean_lap = mean(lap)
        stdev_lap = stdev(lap)
        filter_lap = [i for i in lap if mean_lap-2*stdev_lap < i < mean_lap+2*stdev_lap]
        if self.bounds == 'MANUAL':
            min_def = self.min_def
            max_def = self.max_def
        elif self.bounds == 'AUTOMATIC':
            min_def = min(filter_lap)
            max_def = max(filter_lap)
            self.min_def = min_def
            self.max_def = max_def
        elif self.bounds == 'NEGATIVE':
            min_def = 0
            max_def = min(filter_lap)
            self.min_def = min_def
            self.max_def = max_def
        elif self.bounds == 'POSITIVE':
            min_def = 0

std_test_hamming_loss_th, min_test_hamming_loss_th, max_test_hamming_loss_th, final_test_prec_th, std_test_prec_th,
    min_test_prec_th, max_test_prec_th, final_test_rec_th, std_test_rec_th, min_test_rec_th, max_test_rec_th,
    final_test_fmeasure_th, std_test_fmeasure_th, min_test_fmeasure_th, max_test_fmeasure_th) + "\n"
    output_csv_test = output_csv_test + "\n" + "average" + "," + str(round(final_test_hamming_loss_th, 3)) + "±" + str(
        round(std_test_hamming_loss_th, 3)) + "," + str(round(final_test_acc_th, 3)) + "±" + str(
        round(std_test_acc_th, 3)) + "," + str(round(final_test_prec_th, 3)) + "±" + str(
        round(std_test_prec_th, 3)) + "," + str(round(final_test_rec_th, 3)) + "±" + str(
        round(std_test_rec_th, 3)) + "," + str(round(final_test_fmeasure_th, 3)) + "±" + str(
        round(std_test_fmeasure_th, 3))

    setting = "dataset:" + str(FLAGS.dataset) + "\nC: " + str(FLAGS.C) + "\ngamma: " + str(FLAGS.gamma) + "\nnum_clusters: " + str(FLAGS.num_clusters)
    print("--- The whole program took %s seconds ---" % (time.time() - start_time))
    time_used = "--- The whole program took %s seconds ---" % (time.time() - start_time)
    if FLAGS.kfold != -1:
        print("--- The average training took %s ± %s seconds ---" % (
        sum(time_train) / num_runs, statistics.stdev(time_train)))
        average_time_train = "--- The average training took %s ± %s seconds ---" % (
        sum(time_train) / num_runs, statistics.stdev(time_train))
    else:
        print("--- The average training took %s ± %s seconds ---" % (sum(time_train) / num_runs, 0))
        average_time_train = "--- The average training took %s ± %s seconds ---" % (sum(time_train) / num_runs, 0)

    # output setting configuration, results, prediction and time used
    output_to_file('PLST ' + str(FLAGS.dataset) + " C " + str(FLAGS.C) + ' gamma' + str(FLAGS.gamma) + ' num_clusters' + str(FLAGS.num_clusters) + ' gp_id' + str(
        FLAGS.marking_id) + '.txt',
                   setting + '\n' + output_valid + '\n' + output_test + '\n' + prediction_str + '\n' + time_used + '\n' + average_time_train)
    # output structured evaluation results
    output_to_file('PLST ' + str(FLAGS.dataset) + " C " + str(FLAGS.C) + ' gamma' + str(FLAGS.gamma) + ' num_clusters' + str(FLAGS.num_clusters) + ' gp_id' + str(
        FLAGS.marking_id) + ' valid.csv', output_csv_valid)
    output_to_file('PLST ' + str(FLAGS.dataset) + " C " + str(FLAGS.C) + ' gamma' + str(FLAGS.gamma) + ' num_clusters' + str(FLAGS.num_clusters) + ' gp_id' + str(
        FLAGS.marking_id) + ' test.csv', output_csv_test)

max_test_rec_topk = max(test_rec_topk)
    max_test_fmeasure_topk = max(test_fmeasure_topk)
    max_test_hamming_loss_topk = max(test_hamming_loss_topk)
    
    if FLAGS.kfold != -1:
        std_test_loss = statistics.stdev(test_loss)
        std_test_acc_th = statistics.stdev(test_acc_th) # to change
        std_test_prec_th = statistics.stdev(test_prec_th)
        std_test_rec_th = statistics.stdev(test_rec_th)
        std_test_fmeasure_th = statistics.stdev(test_fmeasure_th)
        std_test_hamming_loss_th = statistics.stdev(test_hamming_loss_th)
        std_test_acc_topk = statistics.stdev(test_acc_topk)
        std_test_prec_topk = statistics.stdev(test_prec_topk)
        std_test_rec_topk = statistics.stdev(test_rec_topk)
        std_test_fmeasure_topk = statistics.stdev(test_fmeasure_topk)
        std_test_hamming_loss_topk = statistics.stdev(test_hamming_loss_topk)
    
    final_test_loss = sum(test_loss)/num_runs # final is average
    final_test_acc_th = sum(test_acc_th)/num_runs
    final_test_prec_th = sum(test_prec_th)/num_runs
    final_test_rec_th = sum(test_rec_th)/num_runs
    final_test_fmeasure_th = sum(test_fmeasure_th)/num_runs
    final_test_hamming_loss_th = sum(test_hamming_loss_th)/num_runs
    final_test_acc_topk = sum(test_acc_topk)/num_runs
    final_test_prec_topk = sum(test_prec_topk)/num_runs
    final_test_rec_topk = sum(test_rec_topk)/num_runs
    final_test_fmeasure_topk = sum(test_fmeasure_topk)/num_runs
    final_test_hamming_loss_topk = sum(test_hamming_loss_topk)/num_runs
    
    print("HAN==>Final Test results Validation Loss:%.3f ± %.3f (%.3f - %.3f)\tValidation Accuracy: %.3f ± %.3f (%.3f - %.3f)\tValidation Hamming Loss: %.3f ± %.3f (%.3f - %.3f)\tValidation Precision: %.3f ± %.3f (%.3f - %.3f)\tValidation Recall: %.3f ± %.3f (%.3f - %.3f)\tValidation F-measure: %.3f ± %.3f (%.3f - %.3f)\tValidation Accuracy@k: %.3f ± %.3f (%.3f - %.3f)\tValidation Hamming Loss@k: %.3f ± %.3f (%.3f - %.3f)\tValidation Precision@k: %.3f ± %.3f (%.3f - %.3f)\tValidation Recall@k: %.3f ± %.3f (%.3f - %.3f)\tValidation F-measure@k: %.3f ± %.3f (%.3f - %.3f)" % (final_test_loss,std_test_loss,min_test_loss,max_test_loss,final_test_acc_th,std_test_acc_th,min_test_acc_th,max_test_acc_th,final_test_hamming_loss_th,std_test_hamming_loss_th,min_test_hamming_loss_th,max_test_hamming_loss_th,final_test_prec_th,std_test_prec_th,min_test_prec_th,max_test_prec_th,final_test_rec_th,std_test_rec_th,min_test_rec_th,max_test_rec_th,final_test_fmeasure_th,std_test_fmeasure_th,min_test_fmeasure_th,max_test_fmeasure_th,final_test_acc_topk,std_test_acc_topk,min_test_acc_topk,max_test_acc_topk,final_test_hamming_loss_topk,std_test_hamming_loss_topk,min_test_hamming_loss_topk,max_test_hamming_loss_topk,final_test_prec_topk,std_test_prec_topk,min_test_prec_topk,max_test_prec_topk,final_test_rec_topk,std_test_rec_topk,min_test_rec_topk,max_test_rec_topk,final_test_fmeasure_topk,std_test_fmeasure_topk,min_test_fmeasure_topk,max_test_fmeasure_topk))
    #output the result to a file
    output_test = output_test + "\n" + "HAN==>Final Test results Validation Loss:%.3f ± %.3f (%.3f - %.3f)\tValidation Accuracy: %.3f ± %.3f (%.3f - %.3f)\tValidation Hamming Loss: %.3f ± %.3f (%.3f - %.3f)\tValidation Precision: %.3f ± %.3f (%.3f - %.3f)\tValidation Recall: %.3f ± %.3f (%.3f - %.3f)\tValidation F-measure: %.3f ± %.3f (%.3f - %.3f)\tValidation Accuracy@k: %.3f ± %.3f (%.3f - %.3f)\tValidation Hamming Loss@k: %.3f ± %.3f (%.3f - %.3f)\tValidation Precision@k: %.3f ± %.3f (%.3f - %.3f)\tValidation Recall@k: %.3f ± %.3f (%.3f - %.3f)\tValidation F-measure@k: %.3f ± %.3f (%.3f - %.3f)" % (final_test_loss,std_test_loss,min_test_loss,max_test_loss,final_test_acc_th,std_test_acc_th,min_test_acc_th,max_test_acc_th,final_test_hamming_loss_th,std_test_hamming_loss_th,min_test_hamming_loss_th,max_test_hamming_loss_th,final_test_prec_th,std_test_prec_th,min_test_prec_th,max_test_prec_th,final_test_rec_th,std_test_rec_th,min_test_rec_th,max_test_rec_th,final_test_fmeasure_th,std_test_fmeasure_th,min_test_fmeasure_th,max_test_fmeasure_th,final_test_acc_topk,std_test_acc_topk,min_test_acc_topk,max_test_acc_topk,final_test_hamming_loss_topk,std_test_hamming_loss_topk,min_test_hamming_loss_topk,max_test_hamming_loss_topk,final_test_prec_topk,std_test_prec_topk,min_test_prec_topk,max_test_prec_topk,final_test_rec_topk,std_test_rec_topk,min_test_rec_topk,max_test_rec_topk,final_test_fmeasure_topk,std_test_fmeasure_topk,min_test_fmeasure_topk,max_test_fmeasure_topk) + "\n"