Let's say I need a 3-digit number, so it would be something like:
>>> random(3)
563
or
>>> random(5)
26748
>> random(2)
56
You can use either of random.randint or random.randrange. So to get a random 3-digit number:
from random import randint, randrange
randint(100, 999) # randint is inclusive at both ends
randrange(100, 1000) # randrange is exclusive at the stop
* Assuming you really meant three digits, rather than "up to three digits".
To use an arbitrary number of digits:
from random import randint
def random_with_N_digits(n):
range_start = 10**(n-1)
range_end = (10**n)-1
return randint(range_start, range_end)
print random_with_N_digits(2)
print random_with_N_digits(3)
print random_with_N_digits(4)
Output:
33
124
5127
If you want it as a string (for example, a 10-digit phone number) you can use this:
n = 10
''.join(["{}".format(randint(0, 9)) for num in range(0, n)])
If you need a 3 digit number and want 001-099 to be valid numbers you should still use randrange/randint as it is quicker than alternatives. Just add the neccessary preceding zeros when converting to a string.
import random
num = random.randrange(1, 10**3)
# using format
num_with_zeros = '{:03}'.format(num)
# using string's zfill
num_with_zeros = str(num).zfill(3)
Alternatively if you don't want to save the random number as an int you can just do it as a oneliner:
'{:03}'.format(random.randrange(1, 10**3))
python 3.6+ only oneliner:
f'{random.randrange(1, 10**3):03}'
Example outputs of the above are:
'026'
'255'
'512'
Implemented as a function that can support any length of digits not just 3:
import random
def n_len_rand(len_, floor=1):
top = 10**len_
if floor > top:
raise ValueError(f"Floor '{floor}' must be less than requested top '{top}'")
return f'{random.randrange(floor, top):0{len_}}'
Does 0 count as a possible first digit? If so, then you need random.randint(0,10**n-1). If not, random.randint(10**(n-1),10**n-1). And if zero is never allowed, then you'll have to explicitly reject numbers with a zero in them, or draw n random.randint(1,9) numbers.
Aside: it is interesting that randint(a,b) uses somewhat non-pythonic "indexing" to get a random number a <= n <= b. One might have expected it to work like range, and produce a random number a <= n < b. (Note the closed upper interval.)
Given the responses in the comments about randrange, note that these can be replaced with the cleaner random.randrange(0,10**n), random.randrange(10**(n-1),10**n) and random.randrange(1,10).
You could write yourself a little function to do what you want:
import random
def randomDigits(digits):
lower = 10**(digits-1)
upper = 10**digits - 1
return random.randint(lower, upper)
Basically, 10**(digits-1) gives you the smallest {digit}-digit number, and 10**digits - 1 gives you the largest {digit}-digit number (which happens to be the smallest {digit+1}-digit number minus 1!). Then we just take a random integer from that range.
import random
fixed_digits = 6
print(random.randrange(111111, 999999, fixed_digits))
out:
271533
You could create a function who consumes an list of int, transforms in string to concatenate and cast do int again, something like this:
import random
def generate_random_number(length):
return int(''.join([str(random.randint(0,10)) for _ in range(length)]))
I really liked the answer of RichieHindle, however I liked the question as an exercise. Here's a brute force implementation using strings:)
import random
first = random.randint(1,9)
first = str(first)
n = 5
nrs = [str(random.randrange(10)) for i in range(n-1)]
for i in range(len(nrs)) :
first += str(nrs[i])
print str(first)
From the official documentation, does it not seem that the sample() method is appropriate for this purpose?
import random
def random_digits(n):
num = range(0, 10)
lst = random.sample(num, n)
print str(lst).strip('[]')
Output:
>>>random_digits(5)
2, 5, 1, 0, 4
I know it's an old question, but I see many solutions throughout the years. here is my suggestion for a function that creates an n digits random string with default 6.
from random import randint
def OTP(n=6):
n = 1 if n< 1 else n
return randint(int("1"*n), int("9"*n))
of course you can change "1"*n to whatever you want the start to be.
Related
import random
number = random.sample(range(0,9999), 10)
print(number, file = open("output.txt","a"))
I want to add (prefix) characters to a randomly generated number.
e.g. AAA(number) so that it will become something like AAA4525. What's the best way to do it?
import random
PREFIX = 'AAA'
numbers = random.sample(range(0,10000), 10) # to include also 9999
with open("output.txt","a") as f:
for number in numbers:
f.write(f'{PREFIX}{number:0>4d}\n')
Simple Concatenation can do the trick for you ..
def converter():
string="AAA"
ans= string+str(number)
return ans
I am trying to generate 4-6 unique numbers in python but when I do uuid.uuuid4(), it generates something like 23dfsFe823FKKS023e343431. Is there a way I can achieve this, generate 4-6 unique numbers like 19391 or 193201.
NB: Beginner with python
yes, to make life easy lets use an easy example.
#lets import random, to generate random stuff
import random
#create a result string
result = ''
nums = [1,2,3,4,5,6,7,8,9,0]
for i in range(6):
result += str(random.choice(nums))
print(result)
UUID is for generating Universally Unique Identifiers, which have a particular structure and won't be what you're after.
You can use the random module as follows
import random
id = ''.join(str(random.randint(0,10)) for x in range(6))
print(id)
What does this do?
randint generates a random number between 0 inclusive and 10 exclusive, i.e. 0-9
calling this with for x in range(6) generates six random digits
str converts the digits to strings
''.join forms a single string from the digits
Try this:
import random
nums = set()
while len(nums) < 4: # change 4 to appropriate number
nums.add(random.randint(0, 1000000))
For example:
>>> nums
set([10928, 906930, 617690, 786206])
You can use random from standard python library
random.randint(a, b)
Return a random integer N such that a <= N <= b.
https://docs.python.org/3/library/random.html#random.randint
In [1]: from random import randint
In [2]: randint(1_000, 999_999)
Out[2]: 587848
In [3]: randint(1_000, 999_999)
Out[3]: 316441
To generate N number of a random number or token by specifying a length of Token this will be an easy and feasible solution.
import random
#num[]: by the combination of this, a random number or token will be generated.
nums = [1,2,3,4,5,6,7,8,9,0]
#all the tokens or random number will be stored in a set called tokens.
#here, we are using a set, because the set will never contain duplicate values.
tokens = set()
result='' #to store temporaray values
while len(tokens) < 10000: # change 10000 to the appropriate number to define the numbers of the random numbers you want to generate.
#change 6 to appropiate number to defined the length of the random number.
for i in range(6):
result+=str(random.choice(nums))
tokens.add(result)
result=''
print(tokens)
#print(len(tokens))
#print(type(tokens))
if you want to use uuid to generate number then you can code something like this
digit = 5 # digits in number
import uuid
for i in range(6):
print(uuid.uuid4().int[:digit])
Or
from uuid import uuid4
result = [ uuid4().int[:5] for i in range(6) ]
I want to create a random number using n numbers which are between i and j. For instance, for n=10 and i=1 and j=5, such an output is expected: 2414243211. I did it in R using this code:
paste(floor(runif(10,1,5)),collapse="") #runif create 10 random number between 1 and 5 and floor make them as integer and finally paste makes them as a sequence of numbers instead of array.
I want to do the same in Python. I found random.uniform but it generates 1 number and I don't want to use loops.
import random
import math
math.floor(random.uniform(1,5)) #just generate 1 number between 1 and 5
update:
i and j are integers between 0 and 9, while n could be any integer.
i and j decide which number can be used in the string while n indicates the length of the numeric string.
If I understand your question (not sure I do), and you have Python 3.6, you can use random.choices:
>>> from random import choices
>>> int(''.join(map(str, choices(range(1, 5), k=10))))
2121233233
The random.choices() function does what you want:
>>> from random import choices
>>> n, i, j = 10, 1, 5
>>> population = list(map(str, range(i, j+1)))
>>> ''.join(choices(population, k=n))
'5143113531'
If you consider list-comprehensions being loops (which they actually in many ways are) there you will not be satisfied with this but I will try my luck:
from random import randint
res = ''.join([str(randint(1, 5)) for _ in range(10)])
print(res) #-> 4353344154
Notes:
The result is a string! If you want an integer, cast to int.
randint works incluselively; the start (1) and end (5) might be produced and returned. If you do not want that, modify them (start = 2 and end = 4)
Is there a reason you are using random.uniform (and subsequently math.floor()) and not simply randint?
x = ''.join([str(math.floor(random.uniform(1,5))) for i in range(10)])
one more question. I am a first year CS student who has to do this on paper, so I am not able to import any programs to solve the problem.
I have been asked to create a psuedo-random set of integers, and then to multiply the products of the integers using a function def product (n). I know this code is really wrong but I'm not really sure what to do at all! Here is what I have so far:
def product(n):
product = j*i
for j in range (20):
i=random.randrange(1,4,1)
print ("The set of numbers is", i)
You didn't specify the range for the integers, but I think this does what you want:
import random
def product(n):
lower_bound = 1
upper_bound = 10
result = 1
for i in range(n):
result *= random.randint(lower_bound, upper_bound)
return result
I would go with
import random
def product(n):
return reduce(lambda x,y:x*y,(random.randint(1,3) for i in xrange(n)))
Several things:
you can't really generate random numbers without importing or writing your own pseudorandom generator
look up reduce. It's probably the preferred method here.
if you can import the operator module, use operator.mul instead of lambda x,y:x*y
If n is the number of generated numbers:
import random
def product(n):
random_list = [random.randint(0,n) for r in xrange(n)]
return reduce(lambda x,y : x*y, random_list)
What do you want? Multiply Integers and display their products? See this :
def product(numberOfIntegers) :
finalResult = 1
for i in range(1,numberOfIntegers) :
randomNumber = random.randrange(1,4,1)
finalResult = finalResult * randomNumber
return finalResult
how do I define decimal range between 0 to 1 in python? Range() function in python returns only int values. I have some variables in my code whose number varies from 0 to 1. I am confused on how do I put that in the code. Thank you
I would add more to my question. There is no step or any increment value that would generate the decimal values. I have to use a variable which could have a value from 0 to 1. It can be any value. But the program should know its boundary that it has a range from 0 to 1. I hope I made myself clear. Thank you
http://docs.python.org/library/random.html
If you are looking for a list of random numbers between 0 and 1, I think you may have a good use of the random module
>>> import random
>>> [random.random() for _ in range(0, 10)]
[0.9445162222544106, 0.17063032908425135, 0.20110591438189673,
0.8392299590767177, 0.2841838551284578, 0.48562600723583027,
0.15468445000916797, 0.4314435745393854, 0.11913358976315869,
0.6793348370697525]
for i in range(100):
i /= 100.0
print i
Also, take a look at decimal.
def float_range(start, end, increment):
int_start = int(start / increment)
int_end = int(end / increment)
for i in range(int_start, int_end):
yield i * increment
This will output decimal number between 0 to 1 with step size 0.1
import numpy as np
mylist = np.arange(0, 1, 0.1)
It seems like list comprehensions would be fairly useful here.
mylist = [x / n for x in range(n)]
Something like that? My Python's rusty.
>>> from decimal import Decimal
>>> [Decimal(x)/10 for x in xrange(11)]
[Decimal("0"), Decimal("0.1"), Decimal("0.2"), Decimal("0.3"), Decimal("0.4"), Decimal("0.5"), Decimal("0.6"), Decimal("0.7"), Decimal("0.8"), Decimal("0.9"), Decimal("1")]
Edit, given comment on Mark Random's answer:
If you really don't want a smoothly incrementing range, but rather a random number between 0 and 1, use random.random().