J'essaie de définir mon propre binning et de calculer la valeur moyenne de certaines autres colonnes de mon Dataframe sur ces bacs. Malheureusement, cela ne fonctionne que avec des entrées entier que vous pouvez voir ci-dessous. Dans ce cas particulier, "step_size" définit l'étape d'une corbeille et j'aimerais utiliser des valeurs de flotteur telles que 0,109, ce qui correspond à 0,109 seconde. Avez-vous une idée de la façon dont je peux faire cela? Je pense que le problème est dans la définition de "Create_bins" mais je ne peux pas le réparer ...
L'objectif devrait être d'obtenir ceci: salue p> [(0,0.109), (0,109,0.218), (0,218,0.327) ......] code> # =============================================================================
# Define parameters
# =============================================================================
seconds_min = 0
seconds_max = 9000
step_size = 1
bin_number = int((seconds_max-seconds_min)/step_size)
# =============================================================================
# Define function to create your own individual binning
# lower_bound defines the lowest value of the binning interval
# width defines the width of the binning interval
# quantity defines the number of bins
# =============================================================================
def create_bins(lower_bound, width, quantity):
bins = []
for low in range(lower_bound,
lower_bound + quantity * width + 1, width):
bins.append((low, low+width))
return bins
# =============================================================================
# Create binning list
# =============================================================================
bin_list = create_bins(lower_bound=seconds_min,
width=step_size,
quantity=bin_number)
print(bin_list)
3 Réponses :
Le problème réside dans le fait que la fonction code> code> ne permet pas aux gammes de flotteur.
Vous pouvez utiliser la fonction numeric_range code> dans plus_itertools Code> Pour cela: P> from more_itertools import numeric_range
seconds_min = 0
seconds_max = 9
step_size = 0.109
bin_number = int((seconds_max-seconds_min)/step_size)
def create_bins(lower_bound, width, quantity):
bins = []
for low in numeric_range(lower_bound,
lower_bound + quantity * width + 1, width):
bins.append((low, low+width))
return bins
bin_list = create_bins(lower_bound=seconds_min,
width=step_size,
quantity=bin_number)
print(bin_list)
# (0.0, 0.109), (0.109, 0.218), (0.218, 0.327) ... ]
Si vous augmentez le secondes_max = 9 valeur sur secondes_max = 20 Après quelques intervalles, vous verrez un comportement étrange comme celui-ci: (16.132, 16.241000000000003) Savez-vous d'où vient-il? Je comprends aussi cela avec les autres approches sous cet article.
Je suppose que cela a quelque chose à voir avec des trucs de précision à virgule flottante. Je ne pense pas que ce soit généralement un problème, mais aussi pour la plupart des applications, à l'exception du moment où vous avez besoin d'un nombre absolument précis. Dans ce cas, vous voudrez peut-être convertir vos numéros en quelque chose comme numpy.flat64 pour plus de précision.
Voici un moyen simple de le faire en utilisant zip code> et numpy's arange code>. J'ai mis la limite supérieure à 5, mais vous pouvez bien sûr choisir d'autres numéros. [(0.0, 0.109),
(0.109, 0.218),
(0.218, 0.327),
(0.327, 0.436),
(0.436, 0.545),
(0.545, 0.654),
(0.654, 0.763),
...
pas de NUMPY:
max_bin=100
min_bin=0
step_size=0.109
number_of_bins = int(1+((max_bin-min_bin)/step_size)) # +1 to cover the whole interval
bins= []
for a in range(number_of_bins):
bins.append((a*step_size, (a+1)*step_size))