Develop Reference

How to convert an array into a new array based on a lookup dictionary

I'm trying to convert a numpy array into a new array by using each value in the existing array and finding its corresponding key from a dictionary. The new array should consist of the corresponding dictionary keys.
Here is what I have:
# dictionary where values are lists
available_weights = {0.009174311926605505: [7, 14, 21, 25, 31, 32, 35, 45, 52, 82, 83, 96, 112, 119, 142], 0.009523809523809525: [33, 37, 43, 44, 69, 73, 75, 78, 79, 80, 102, 104, 110, 115, 150], 0.1111111111111111: [91], 0.019230769230769232: [36, 50, 127, 139], 0.010869565217391304: [10, 48, 55, 62, 77, 88, 103, 124, 131, 137, 147], 0.014084507042253521: [2, 3, 4, 22, 27, 30, 41, 53, 87, 122, 123, 132, 143], 0.011494252873563218: [20, 34, 99, 125, 135, 138, 141], 0.045454545454545456: [0, 109], 0.01818181818181818: [49, 64, 72, 90, 146, 148], 0.07142857142857142: [106], 0.01282051282051282: [16, 63, 68, 98, 114, 130, 145], 0.010638297872340425: [8, 28, 40, 57, 61, 66, 71, 74, 76, 84, 85, 86, 128, 144], 0.02040816326530612: [6, 65], 0.021739130434782608: [29, 67, 92, 93], 0.02127659574468085: [47, 118, 120], 0.011111111111111112: [1, 13, 19, 24, 42, 54, 70, 89, 94, 107, 117, 126, 129, 140], 0.015625: [38, 60, 101, 133, 134, 136], 0.03333333333333333: [56, 58, 97, 121], 0.016666666666666666: [5, 26, 105, 113], 0.014705882352941176: [17, 46, 95]}
# existing numpy array
train_idx = [134, 45, 137, 140, 79, 98, 128, 80, 99, 71, 145, 35, 94, 122, 77, 23, 113, 44, 68, 21, 20, 125, 74, 139, 29, 109, 25, 34, 6, 81, 22, 114, 12, 95, 150, 106, 84, 19, 58, 59, 88, 143, 136, 43, 72, 132, 117, 13, 65, 111, 39, 14, 56, 11, 26, 90, 119, 112, 27, 57, 46, 147, 123, 16, 36, 100, 141, 38, 62, 32, 75, 146, 89, 37, 31, 40, 64, 87, 3, 103, 102, 104, 78, 53, 1, 142, 47, 130, 105, 4, 93, 52, 42, 10, 9, 115, 76, 54, 49, 116, 69, 5, 86, 66, 101, 107, 96, 110, 8, 73, 121, 138, 67, 124, 108, 97, 120, 2, 148, 127, 135, 18, 149, 82, 41, 144, 129, 118, 51, 126, 33, 85, 24, 0, 61, 92, 70, 15, 17, 50, 83, 30, 28, 91, 60, 48, 133, 55, 63, 7, 131]
So I want to use each value in train_idx to find the corresponding dictionary key in available_weights. The expected output should look like this (with a length of all 150 values):
new_array = [0.015625, 0.009174311926605505, 0.010869565217391304, ... ,0.01282051282051282, 0.009174311926605505, 0.010869565217391304]
Any help would be appreciated!

result = []
flipped = dict()
for value in train_idx:
flipped[value] = []
for key in available_weights:
if value in available_weights[key]:
flipped[value].append(key)
result.append(key)

how to generate combinations from multiple variables?

I have following variables;
D8 =[22, 27, 28, 30, 31, 40, 41, 42, 43, 45]
D9 = [79, 80, 90, 92, 93, 97, 98, 104, 105, 109]
D10=[61, 64, 66, 70, 72, 76, 81, 86, 87]
By using above variables, I tried to generate all the possible combinations as follows;
import itertools
stuff = [D8, D9, D10]
for L in range(0, len(stuff)+1):
for subset in itertools.combinations(stuff, L):
print(subset)
The result depicts as follows;
Output>>>
()
([22, 27, 28, 30, 31, 40, 41, 42, 43, 45],)
([79, 80, 90, 92, 93, 97, 98, 104, 105, 109],)
([61, 64, 66, 70, 72, 76, 81, 86, 87],)
([22, 27, 28, 30, 31, 40, 41, 42, 43, 45], [79, 80, 90, 92, 93, 97, 98, 104, 105, 109])
([22, 27, 28, 30, 31, 40, 41, 42, 43, 45], [61, 64, 66, 70, 72, 76, 81, 86, 87])
([79, 80, 90, 92, 93, 97, 98, 104, 105, 109], [61, 64, 66, 70, 72, 76, 81, 86, 87])
([22, 27, 28, 30, 31, 40, 41, 42, 43, 45], [79, 80, 90, 92, 93, 97, 98, 104, 105, 109], [61, 64, 66, 70, 72, 76, 81, 86, 87])
I want to know is there any other cleaner method to generate the above result, because in the current output I cannot flat each result into each individual outcome? Expected result should be like this?
Expected Result>>>
([])
([22, 27, 28, 30, 31, 40, 41, 42, 43, 45])
([79, 80, 90, 92, 93, 97, 98, 104, 105, 109])
([61, 64, 66, 70, 72, 76, 81, 86, 87])
([22, 27, 28, 30, 31, 40, 41, 42, 43, 45, 79, 80, 90, 92, 93, 97, 98, 104, 105, 109])
([22, 27, 28, 30, 31, 40, 41, 42, 43, 45, 61, 64, 66, 70, 72, 76, 81, 86, 87])
([79, 80, 90, 92, 93, 97, 98, 104, 105, 109, 61, 64, 66, 70, 72, 76, 81, 86, 87])
([22, 27, 28, 30, 31, 40, 41, 42, 43, 45, 79, 80, 90, 92, 93, 97, 98, 104, 105, 109, 61, 64, 66, 70, 72, 76, 81, 86, 87])
Thank you in advanced!!!

The itertools documentation contains the recipe flatten:
def flatten(list_of_lists):
"Flatten one level of nesting"
return chain.from_iterable(list_of_lists)
which you need to apply twice to get the desired result:
from itertools import combinations, chain
D8 = [22, 27, 28, 30, 31, 40, 41, 42, 43, 45]
D9 = [79, 80, 90, 92, 93, 97, 98, 104, 105, 109]
D10 = [61, 64, 66, 70, 72, 76, 81, 86, 87]
stuff = [D8, D9, D10]
def flatten(list_of_lists):
"""Flatten one level of nesting"""
return chain.from_iterable(list_of_lists)
result = flatten(map(flatten, combinations(stuff, length)) for length in range(len(stuff) + 1))
for xs in result:
print(list(xs))
producing:
[]
[22, 27, 28, 30, 31, 40, 41, 42, 43, 45]
[79, 80, 90, 92, 93, 97, 98, 104, 105, 109]
[61, 64, 66, 70, 72, 76, 81, 86, 87]
[22, 27, 28, 30, 31, 40, 41, 42, 43, 45, 79, 80, 90, 92, 93, 97, 98, 104, 105, 109]
[22, 27, 28, 30, 31, 40, 41, 42, 43, 45, 61, 64, 66, 70, 72, 76, 81, 86, 87]
[79, 80, 90, 92, 93, 97, 98, 104, 105, 109, 61, 64, 66, 70, 72, 76, 81, 86, 87]
[22, 27, 28, 30, 31, 40, 41, 42, 43, 45, 79, 80, 90, 92, 93, 97, 98, 104, 105, 109, 61, 64, 66, 70, 72, 76, 81, 86, 87]

Hot to sketch a curve and convert it to numpy

I am in a real need of a tool that does the following:
You draw with your mouse a curve from a starting point to a finish point and then it exports this to an object, which can then be interpolated as a numpy array to a given number of points.
Is anybody aware of such tool, or a way to achieve something similar?
Thanks

This might get you started. Draw your curve with Photoshop, GIMP or your favourite painting/drawing program and save it as a white line on a black background in PNG/GIF/JPEG/TIFF format, or any other format that PIL/Pillow understands:
Load the image with PIL/Pillow, blur it a little to allow for discontinuities in your hand-drawn-curve, then find the brightest pixel in each column. Save as a ".npy" file that you can load and interpolate to any dimension of array you want:
#!/usr/bin/env python3
import sys
import numpy as np
from PIL import Image, ImageFilter
# Check an image file was supplied
if len(sys.argv) != 2:
print("Usage: curve2array IMAGE", file=sys.stderr)
exit(1)
# Assign filename and open image as greyscale
filename = sys.argv[1]
im = Image.open(filename).convert('L')
# OPTIONAL = Blur the image a little to allow discontinuities in hand-sketched curves
im = im.filter(ImageFilter.GaussianBlur(1))
# Convert image to Numpy array and get row number of brightest pixel in each column
na = np.array(im)
yvals = np.argmax(im, axis=0)
yvals = na.shape[0] - yvals # Make origin at bottom-left instead of top-left
# Write result as ".npy" file
np.save('result.npy', yvals)
My input image is 600px wide by 400 pixels tall, so there are 600 y-values and the last is the largest one at 394 because it's near the top of a 400 px high image. The array looks like this:
array([ 1, 1, 3, 6, 10, 13, 16, 20, 23, 26, 29, 32, 36,
39, 42, 45, 48, 51, 54, 57, 59, 62, 65, 68, 71, 74,
76, 79, 82, 84, 87, 90, 92, 95, 97, 100, 102, 104, 107,
109, 111, 114, 116, 118, 120, 123, 125, 127, 129, 131, 133, 135,
137, 139, 140, 142, 144, 146, 148, 149, 151, 153, 154, 156, 157,
159, 160, 162, 163, 164, 166, 167, 168, 169, 171, 172, 173, 174,
175, 176, 177, 178, 179, 180, 180, 181, 182, 182, 183, 184, 184,
185, 185, 186, 186, 187, 187, 187, 188, 188, 188, 188, 188, 188,
188, 188, 188, 188, 188, 187, 187, 187, 186, 186, 185, 185, 184,
184, 183, 182, 181, 180, 180, 179, 178, 177, 176, 175, 173, 172,
171, 170, 169, 167, 166, 165, 163, 162, 160, 159, 157, 156, 155,
153, 152, 150, 149, 147, 145, 144, 142, 141, 139, 138, 136, 135,
133, 132, 130, 129, 127, 126, 124, 123, 121, 120, 119, 117, 116,
114, 113, 112, 110, 109, 108, 106, 105, 104, 103, 101, 100, 99,
98, 97, 96, 95, 94, 92, 91, 90, 89, 88, 87, 86, 85,
85, 84, 83, 82, 81, 80, 79, 79, 78, 77, 76, 75, 75,
74, 73, 72, 72, 71, 70, 70, 69, 68, 68, 67, 66, 66,
65, 64, 64, 63, 63, 62, 61, 61, 60, 60, 59, 58, 58,
57, 57, 56, 56, 55, 55, 54, 54, 53, 53, 52, 52, 51,
51, 50, 50, 49, 49, 48, 48, 47, 47, 47, 46, 46, 45,
45, 45, 44, 44, 43, 43, 43, 42, 42, 42, 41, 41, 41,
40, 40, 40, 39, 39, 39, 38, 38, 38, 38, 37, 37, 37,
37, 36, 36, 36, 36, 36, 35, 35, 35, 35, 35, 34, 34,
34, 34, 34, 34, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35,
36, 36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 39,
39, 39, 40, 40, 40, 41, 41, 41, 42, 42, 42, 43, 43,
43, 44, 44, 45, 45, 46, 46, 46, 47, 47, 48, 48, 49,
49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 55, 55, 56,
56, 57, 57, 58, 59, 59, 60, 60, 61, 62, 62, 63, 64,
64, 65, 66, 66, 67, 68, 69, 69, 70, 71, 72, 72, 73,
74, 75, 75, 76, 77, 78, 79, 79, 80, 81, 82, 83, 84,
85, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
110, 111, 112, 113, 115, 116, 117, 118, 119, 120, 121, 123, 124,
125, 126, 128, 129, 130, 131, 133, 134, 135, 136, 138, 139, 140,
142, 143, 145, 146, 147, 149, 150, 152, 153, 155, 156, 157, 159,
160, 162, 163, 165, 167, 168, 170, 171, 173, 175, 176, 178, 179,
181, 183, 185, 186, 188, 190, 192, 193, 195, 197, 199, 201, 203,
204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 229,
231, 233, 235, 237, 239, 242, 244, 246, 248, 251, 253, 256, 258,
261, 263, 266, 268, 271, 273, 276, 279, 281, 284, 287, 290, 292,
295, 298, 301, 304, 307, 310, 314, 317, 320, 323, 327, 330, 334,
337, 341, 344, 348, 352, 356, 360, 364, 368, 372, 376, 381, 385,
390, 394])
I saved the script above as curve2array, so I run it with:
./curve2array image.png

How do you use for loop to find the minimum without using something similar to "min" on Python?

This is what I have so far, but I would like to use it without min and with for loop:
Numbers = [100, 97, 72, 83, 84, 78, 89, 84, 83, 75, 54, 98, 70, 88, 99, 69, 70, 79, 55, 82, 81, 75, 54, 82, 56, 73, 90, 100, 94, 89, 56, 64, 51, 72, 64, 94, 63, 82, 77, 68, 60, 93, 95, 60, 77, 78, 74, 67, 72, 99, 93, 79, 76, 86, 87, 74, 82]
for i in range(len(Numbers)):
print(min(Numbers))

I do not know why you do not want to use min (you should) - but if you do not want to you can loop over the numbers and keep track of the smallest.
min_ = None
for n in Numbers:
if min_ is None or n < min_:
min_ = n
min_ is now the minimum in the list Numbers.

Another identical method is:
numbers = [100, 97, 72, 83, 84, 78, 89, 84, 83, 75, 54, 98, 70, 88, 99, 69, 70, 79, 55, 82, 81, 75, 54, 82, 56, 73, 90, 100, 94, 89, 56, 64, 51, 72, 64, 94, 63, 82, 77, 68, 60, 93, 95, 60, 77, 78, 74, 67, 72, 99, 93, 79, 76, 86, 87, 74, 82]
smallest = None
for x in range(len(numbers)):
if (smallest == None or numbers[x] < smallest):
smallest = numbers[x]
print(smallest)
Output:
51

Averaging Vertically in Nested Lists

I am writing a grade book program that sets a nested list with assignments as columns and individual students along the rows. The program must calculate the average for each assignment and the average for each student. I've got the average by student, but now I can't figure out how to calculate the average by assignment. Any help would be appreciated!
# gradebook.py
# Display the average of each student's grade.
# Display tthe average for each assignment.
gradebook = [61, 74, 69, 62, 72, 66, 73, 65, 60, 63, 69, 63,
62, 61, 64],
[73, 80, 78, 76, 76, 79, 75, 73, 76, 74, 77, 79, 76,
78, 72],
[90, 92, 93, 92, 88, 93, 90, 95, 100, 99, 100, 91, 95, 99, 96],
[96, 89, 94, 88, 100, 96, 93, 92, 94, 98, 90, 90, 92, 91, 94],
[76, 76, 82, 78, 82, 76, 84, 82, 80, 82, 76, 86, 82, 84, 78],
[93, 92, 89, 84, 91, 86, 84, 90, 95, 86, 88, 95, 88, 84, 89],
[63, 66, 55, 67, 66, 68, 66, 56, 55, 62, 59, 67, 60, 70, 67],
[86, 92, 93, 88, 90, 90, 91, 94, 90, 86, 93, 89, 94, 94, 92],
[89, 80, 81, 89, 86, 86, 85, 80, 79, 90, 83, 85, 90, 79, 80],
[99, 73, 86, 77, 87, 99, 71, 96, 81, 83, 71, 75, 91, 74, 72]]
#make variable for assingment averages
#make a variable for student averages
stu_avg = [sum(row)/len(row) for row in gradebook]
print(stu_avg)
#Assignment Class
class Assignment:
def __init__(self, name, average):
self.average = average
self.name = name
def print_grade(self):
print("Assignment", self.name, ":", self.average)
#Student Class
class Student:
def __init__(self, name, average):
self.average = average
self.name = name
def print_grade(self):
print("Student", self.name, ":", self.average)
s1 = Student("1", stu_avg[0])
s2 = Student("2", stu_avg[1])
s3 = Student("3", stu_avg[2])
s4 = Student("4", stu_avg[3])
s5 = Student("5", stu_avg[4])
s6 = Student("6", stu_avg[5])
s7 = Student("7", stu_avg[6])
s8 = Student("8", stu_avg[7])
s9 = Student("9", stu_avg[8])
s10 = Student("10", stu_avg[9])
s1.print_grade()
s2.print_grade()
s3.print_grade()
s4.print_grade()
s5.print_grade()
s6.print_grade()
s7.print_grade()
s8.print_grade()
s9.print_grade()
s10.print_grade()

Instead of using loops, let's use matrices. They make calculation much much faster, especially when dealing with large datasets.
As an example,
Per student:
[1, 2, 3, 4] [1]
[4, 5, 6, 6] x [1]
[1, 1, 3, 1] [1]
Per assignment
[1, 2, 3, 4]T [1]
[4, 5, 6, 6] x [1]
[1, 1, 3, 1] [1]
The first operation returns per student sum, and the second returns per test sum. Divide appropriately to get the average.
Using numpy
import numpy as np
gradebook = [[61, 74, 69, 62, 72, 66, 73, 65, 60, 63, 69, 63, 62, 61, 64],
[73, 80, 78, 76, 76, 79, 75, 73, 76, 74, 77, 79, 76, 78, 72],
[90, 92, 93, 92, 88, 93, 90, 95, 100, 99, 100, 91, 95, 99, 96],
[96, 89, 94, 88, 100, 96, 93, 92, 94, 98, 90, 90, 92, 91, 94],
[76, 76, 82, 78, 82, 76, 84, 82, 80, 82, 76, 86, 82, 84, 78],
[93, 92, 89, 84, 91, 86, 84, 90, 95, 86, 88, 95, 88, 84, 89],
[63, 66, 55, 67, 66, 68, 66, 56, 55, 62, 59, 67, 60, 70, 67],
[86, 92, 93, 88, 90, 90, 91, 94, 90, 86, 93, 89, 94, 94, 92],
[89, 80, 81, 89, 86, 86, 85, 80, 79, 90, 83, 85, 90, 79, 80],
[99, 73, 86, 77, 87, 99, 71, 96, 81, 83, 71, 75, 91, 74, 72]]
def get_student_average(gradebook):
number_of_students = len(gradebook[0])
number_of_assignments = len(gradebook)
matrix = [1] * number_of_students
# [1, 1, 1, 1, ...]. This is 1 * 15. Need to transpose to make it 15*1
# Converting both to numpy matrices
matrix = np.array(matrix)
gradebook = np.array(gradebook)
# Transposing matrix and multiplying them
print(gradebook.dot(matrix.T))
def get_assignment_average(gradebook):
number_of_students = len(gradebook[0])
number_of_assignments = len(gradebook)
matrix = [1] * number_of_assignments
# [1, 1, 1, ...] . This is 1 * 10. Need to transpose to make it 10*1
matrix = np.array(matrix)
gradebook = np.array(gradebook)
gradebook = gradebook.T
matrix = matrix.T
print(gradebook.dot(matrix))
get_student_average(gradebook)
get_assignment_average(gradebook)
Results
student_avg -> [ 984 1142 1413 1397 1204 1334 947 1362 1262 1235]
test_avg -> [826 814 820 801 838 839 812 823 810 823 806 820 830 814 804]