generate 100 normally distributed random numbers in python

import numpy as np

L = np.random.normal(1.0, 0.005, 100)

uniformrandom() is not returning anything. You need to add a return statement:

def uniformrandom(n):
   i = 0
while i < n:
   gauss(1.0, 0.005)
i = i + 1
return i

That is returning the number of gauss's, though. You aren't even storing the gauss() calls in a list. You should change your function to this:

def uniformrandom(n):
   gausses = []
for _ in range(n):
   gausses.append(gauss(1.0, 0.005))
return gausses

You could even use a list comprehension:

def uniformrandom(n):
   return [gauss(1.0, 0.005) for _ in range(n)]

For example, to generate a single suitable number:

def uniformrandom_1():
   return gauss(1.0, 0.005)

now, if you want a list of n numbers, you can just use

[uniformrandom_1() for i in range(n)]

or write that as a function:

def uniformrandom(n):
   return [uniformrandom_1() for i in range(n)]

Try the following code,

def uniformrandom(n):
   nums = []
total = 0
i = 0
for i in range(1, n):
   num = gauss(1.0, 0.005)
nums.append(num)
total += num
return (nums, total / n)

This will create a list with n random numbers using gauss. import random as rd

def uniformrandom(n):
   i = 0
random_list = [] * n
for i in range(n):
   random_list += [rd.gauss(1, 0.005)]
return random_list

In order to generate 100 normally distributed random numbers in Python by using the function gauss with expectation 1.0 and standard deviation 0.005, one can use numpy.random.normal as follows

import numpy as np

random_numbers = np.random.normal(1.0, 0.005, 100)

In order to store the random_numbers in an array, one can do that with numpy.array as follows

random_numbers_array = np.array(random_numbers)

Then to calculate the mean use numpy.mean

mean = np.mean(random_numbers_array)

A function, that takes as input the mean and std of the random number generator, and does what OP wants, can be something like

def uniformrandom(mean, std):
   random_numbers = np.random.normal(mean, std, 100)
random_numbers_array = np.array(random_numbers)
mean = np.mean(random_numbers_array)
std = np.std(random_numbers_array)
return random_numbers_array, mean, std

Let's see what it retrieves

print(uniformrandom(1.0, 0.005))

[Out]:
(array([1.00716042, 0.99938042, 0.99178698, 1.00791888, 1.00623344,
   1.00555578, 0.99890757, 1.00695046, 0.98482516, 0.9928371,
   1.00016377, 0.99510195, 1.00280951, 0.99472607, 0.99453582,
   1.00791222, 1.00302319, 1.00004503, 0.99884054, 1.00429994,
   0.99591756, 1.010769, 1.00827643, 0.996754, 0.99236853,
   1.00096622, 1.00092158, 1.00192217, 1.00148108, 0.9975529,
   1.00953799, 1.0073464, 0.99942883, 1.0065139, 1.00265884,
   1.00885268, 0.99613224, 1.00299541, 0.99977556, 1.01090735,
   1.00132776, 0.99711267, 1.00129545, 1.00500702, 0.99937595,
   1.00603761, 0.98960716, 0.99932355, 0.99687272, 1.00332839,
   0.991147, 0.99643908, 0.99279811, 1.00112179, 1.00012058,
   0.9989405, 1.00150169, 1.00683601, 0.99885708, 0.99632519,
   1.00112315, 0.99280336, 1.00759542, 1.00140661, 1.00183764,
   0.99540866, 1.0002343, 0.99421579, 1.01169739, 1.00330142,
   0.99977923, 1.00365608, 0.9984007, 1.00106568, 1.00349778,
   0.99527499, 0.99189253, 0.99477082, 0.99486919, 0.99784054,
   0.99240925, 1.00417557, 0.99566904, 1.00355492, 0.99717846,
   0.99910477, 0.99718301, 1.00711659, 0.99623698, 1.00143697,
   1.00876763, 1.0049953, 0.99885742, 0.99498201, 1.00324752,
   0.99907905, 0.99762597, 0.99502917, 0.99511507, 1.00991401
]), 1.0002981820807302, 0.005332038881947385)

Suggestion : 2

To generate five random numbers from the normal distribution we will use numpy.random.normal() method of the random module. ,Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.,In Numpy we are provided with the module called random module that allows us to work with random numbers. The random module provides different methods for data distribution. In this article, we have to create an array of specified shape and fill it random numbers or values such that these values are part of a normal distribution or Gaussian distribution. This distribution is also called the Bell Curve this is because of its characteristics shape.,CS SubjectsMathematicsOperating SystemDBMSComputer NetworksComputer Organization and ArchitectureTheory of ComputationCompiler DesignDigital LogicSoftware Engineering

Output :

[0.27491897 - 0.18001994 - 0.01783066 1.07701319 - 0.11356911]

Suggestion : 3

Draw random samples from a normal (Gaussian) distribution.,The normal distributions occurs often in nature. For example, it describes the commonly occurring distribution of samples influenced by a large number of tiny, random disturbances, each with its own unique distribution [2].,Drawn samples from the parameterized normal distribution.,The probability density function of the normal distribution, first derived by De Moivre and 200 years later by both Gauss and Laplace independently [2], is often called the bell curve because of its characteristic shape (see the example below).

>>> mu, sigma = 0, 0.1 # mean and standard deviation >>>
   s = np.random.normal(mu, sigma, 1000)

>>> abs(mu - np.mean(s))
0.0 # may vary

>>> abs(sigma - np.std(s, ddof = 1))
0.1 # may vary

>>>
import matplotlib.pyplot as plt >>>
   count, bins, ignored = plt.hist(s, 30, density = True) >>>
   plt.plot(bins, 1 / (sigma * np.sqrt(2 * np.pi)) *
      ...np.exp(-(bins - mu) ** 2 / (2 * sigma ** 2)),
      ...linewidth = 2, color = 'r') >>>
   plt.show()

>>> np.random.normal(3, 2.5, size = (2, 4))
array([
   [-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random[0.39924804, 4.68456316, 4.99394529, 4.84057254]
]) # random

Suggestion : 4

Random numbers from a normal distribution can be generated using runif() function.,Random numbers from a normal distribution can be generated using rnorm() function.,For example, runif() generates random numbers from a uniform distribution and rnorm() generates from a normal distribution.,We need to specify how many numbers we want to generate.

Example: Uniform Distribution

> runif(1) # generates 1 random number[1] 0.3984754 >
   runif(3) # generates 3 random number[1] 0.8090284 0.1797232 0.6803607 >
   runif(3, min = 5, max = 10) # define the range between 5 and 10[1] 7.099781 8.355461 5.173133

Example: Normal Distribution

> rnorm(1) # generates 1 random number[1] 1.072712 >
   rnorm(3) # generates 3 random number[1] - 1.1383656 0.2016713 - 0.4602043 >
   rnorm(3, mean = 10, sd = 2) # provide our own mean and standard deviation[1] 9.856933 9.024286 10.822507

Suggestion : 5

In this chapter we introduce how to generate random numbers from various distributions in Python. The core library we will be using is the numpy library which contains a powerful random number generator. We will then draw random numbers from different distributions and graph these numbers using histograms in order to check the shape of the distribution that these numbers follow.,Here is another example of two normally distributed random variables. The first random variable has a smaller standard deviation than the second. Let us see how the distribution of these two compare.,Draw 100 random numbers from a Standard Normal distribution,We next make a histogram of these numbers to see the shape of the distribution where they come from. I set the number of bars in the histogram to 30 in order to get a nice picture.

import numpy as np
import matplotlib.pyplot as plt
import math
from scipy
import stats as st
import time # Imports system time module to time your script

plt.close('all') # close all open figures
tic = time.time()

myNumber = np.random.uniform(0, 1)
print('My first random number in [0,1] is {}'.format(myNumber))

My first random number in [0, 1] is 0.8602692305307852

myNumber = np.random.uniform(0, 1)
print('My second random number in [0,1] is {}'.format(myNumber))

My second random number in [0, 1] is 0.42116143252571125

np.random.seed(123456789)
myNumber = np.random.uniform(0, 1)
print('My first random number in [0,1] is {}'.format(myNumber))