Help(Random)

Python 3.1.2 (r312:79147, Sep 27 2010, 09:45:41) 
[GCC 4.4.3] on linux2
Type "copyright", "credits" or "license()" for more information.
==== No Subprocess ====
>>> from random import Random
>>> help(Random)
Help on class Random in module random:

class Random(_random.Random)
 |  Random number generator base class used by bound module functions.
 |  
 |  Used to instantiate instances of Random to get generators that don't
 |  share state.
 |  
 |  Class Random can also be subclassed if you want to use a different basic
 |  generator of your own devising: in that case, override the following
 |  methods:  random(), seed(), getstate(), and setstate().
 |  Optionally, implement a getrandbits() method so that randrange()
 |  can cover arbitrarily large ranges.
 |  
 |  Method resolution order:
 |      Random
 |      _random.Random
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getstate__(self)
 |  
 |  __init__(self, x=None)
 |      Initialize an instance.
 |      
 |      Optional argument x controls seeding, as for Random.seed().
 |  
 |  __reduce__(self)
 |  
 |  __setstate__(self, state)
 |  
 |  betavariate(self, alpha, beta)
 |      Beta distribution.
 |      
 |      Conditions on the parameters are alpha > 0 and beta > 0.
 |      Returned values range between 0 and 1.
 |  
 |  choice(self, seq)
 |      Choose a random element from a non-empty sequence.
 |  
 |  expovariate(self, lambd)
 |      Exponential distribution.
 |      
 |      lambd is 1.0 divided by the desired mean.  It should be
 |      nonzero.  (The parameter would be called "lambda", but that is
 |      a reserved word in Python.)  Returned values range from 0 to
 |      positive infinity if lambd is positive, and from negative
 |      infinity to 0 if lambd is negative.
 |  
 |  gammavariate(self, alpha, beta)
 |      Gamma distribution.  Not the gamma function!
 |      
 |      Conditions on the parameters are alpha > 0 and beta > 0.
 |  
 |  gauss(self, mu, sigma)
 |      Gaussian distribution.
 |      
 |      mu is the mean, and sigma is the standard deviation.  This is
 |      slightly faster than the normalvariate() function.
 |      
 |      Not thread-safe without a lock around calls.
 |  
 |  getstate(self)
 |      Return internal state; can be passed to setstate() later.
 |  
 |  lognormvariate(self, mu, sigma)
 |      Log normal distribution.
 |      
 |      If you take the natural logarithm of this distribution, you'll get a
 |      normal distribution with mean mu and standard deviation sigma.
 |      mu can have any value, and sigma must be greater than zero.
 |  
 |  normalvariate(self, mu, sigma)
 |      Normal distribution.
 |      
 |      mu is the mean, and sigma is the standard deviation.
 |  
 |  paretovariate(self, alpha)
 |      Pareto distribution.  alpha is the shape parameter.
 |  
 |  randint(self, a, b)
 |      Return random integer in range [a, b], including both end points.
 |  
 |  randrange(self, start, stop=None, step=1, int=, default=None, maxwidth=9007199254740992)
 |      Choose a random item from range(start, stop[, step]).
 |      
 |      This fixes the problem with randint() which includes the
 |      endpoint; in Python this is usually not what you want.
 |      Do not supply the 'int', 'default', and 'maxwidth' arguments.
 |  
 |  sample(self, population, k)
 |      Chooses k unique random elements from a population sequence or set.
 |      
 |      Returns a new list containing elements from the population while
 |      leaving the original population unchanged.  The resulting list is
 |      in selection order so that all sub-slices will also be valid random
 |      samples.  This allows raffle winners (the sample) to be partitioned
 |      into grand prize and second place winners (the subslices).
 |      
 |      Members of the population need not be hashable or unique.  If the
 |      population contains repeats, then each occurrence is a possible
 |      selection in the sample.
 |      
 |      To choose a sample in a range of integers, use range as an argument.
 |      This is especially fast and space efficient for sampling from a
 |      large population:   sample(range(10000000), 60)
 |  
 |  seed(self, a=None)
 |      Initialize internal state from hashable object.
 |      
 |      None or no argument seeds from current time or from an operating
 |      system specific randomness source if available.
 |      
 |      If a is not None or an int, hash(a) is used instead.
 |  
 |  setstate(self, state)
 |      Restore internal state from object returned by getstate().
 |  
 |  shuffle(self, x, random=None, int=)
 |      x, random=random.random -> shuffle list x in place; return None.
 |      
 |      Optional arg random is a 0-argument function returning a random
 |      float in [0.0, 1.0); by default, the standard random.random.
 |  
 |  triangular(self, low=0.0, high=1.0, mode=None)
 |      Triangular distribution.
 |      
 |      Continuous distribution bounded by given lower and upper limits,
 |      and having a given mode value in-between.
 |      
 |      http://en.wikipedia.org/wiki/Triangular_distribution
 |  
 |  uniform(self, a, b)
 |      Get a random number in the range [a, b) or [a, b] depending on rounding.
 |  
 |  vonmisesvariate(self, mu, kappa)
 |      Circular data distribution.
 |      
 |      mu is the mean angle, expressed in radians between 0 and 2*pi, and
 |      kappa is the concentration parameter, which must be greater than or
 |      equal to zero.  If kappa is equal to zero, this distribution reduces
 |      to a uniform random angle over the range 0 to 2*pi.
 |  
 |  weibullvariate(self, alpha, beta)
 |      Weibull distribution.
 |      
 |      alpha is the scale parameter and beta is the shape parameter.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  VERSION = 3
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from _random.Random:
 |  
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |  
 |  getrandbits(...)
 |      getrandbits(k) -> x.  Generates a long int with k random bits.
 |  
 |  random(...)
 |      random() -> x in the interval [0, 1).
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _random.Random:
 |  
 |  __new__ = 
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T

>>>