根据Python中的变量生成随机值

Question

I am trying to generate a random number based on accuracy of a player. If his accuracy is more, his cost should be more.

For ex,

      if accuracy >= 0.9, cost = 0.7

      else if accuracy >= 0.8, cost = 0.6
      (something like this)

cost is a random floating point number between 0 and user_specified_value. If his accuracy is closer to 1, I want cost to be generated closer to user_specified_value.

How do I generate the cost based on the accuracy?

Thank you.

Answer 1

from __future__ import division ## this lets us do non integer division
import random

user_specified_value = 5

if accuracy >= 0.9:
    cost = random.randrange(user_specified_value//2,user_specified_value,1)/10
else:
    cost = random.randrange(0,user_specified_value,1)/10

Because we imported __future__ all division using / will be floating point division. If you want integer division just use // . Float division is the default in python 3.

random.randrange doesn't like non-integers, so if you want a decimal cost you have to specify user_specified_value as an integer.

Answer 2

What I think you're asking about is sampling from a distribution.

Python's random module provides several distributions, the choice of which depends on what you want for your application. For example random.random() returns floating points uniformly distributed between 0.0 and 1.0.

Uniform

You might want to sample costs uniformly from a band that gets higher with accuracy, like this:

cost = (random.random() * spread + min(accuracy, (1-spread))) * user_specified_value

Spread defines how wide the band is, and we draw uniformly within the band, sliding the band upward as accuracy increases stopping when we bump up against 100%.

Let's see how this looks, generating 1000 random samples:

The y axis here is cost. The x axis is just the order in which the samples were drawn and is meaningless. Here's what you get for low accuracy (0.01)

Dialing the accuracy up to 0.30, get's you random costs in this range:

And for highly accurate players (0.99), we get:

Triangular distribution

Another way to scale up the costs would be to use a triangular distribution , something like this:

cost = random.triangular(0.0,max(0.01,accuracy),1.0)

This time, the x axis is accuracy, the cost, y, scales up gradually. Note that a highly accurate player can still get a low cost, but a low accuracy player never gets a high cost:

BTW, I used the plotting library matplotlib and the following code to generate these nifty plots.

import numpy as np
import matplotlib.pyplot as plt
import random

user_specified_value = 100.0
spread = 0.33
n = 1000

## uniform
accuracy = 0.01
costs = [0] * n
for i in range(0,n):
    costs[i] = random.random() * user_specified_value * accuracy
plt.scatter(range(0,n), costs)
plt.ylim(0, 100)

## triangular
accuracy = [0] * n
costs = [0] * n
for i in range(0,n):
    accuracy[i] = float(i)/n
    costs[i] = random.triangular(0.0,max(0.01,accuracy[i]),1.0) * user_specified_value
plt.scatter(accuracy, costs)