# python生成四位随机数

• random下有三个可以随机取数的函数，分别是choicechoicessample
```1 # random.choice
2 def choice(self, seq):
3         """Choose a random element from a non-empty sequence."""
4         try:
5             i = self._randbelow(len(seq))
6         except ValueError:
7             raise IndexError(‘Cannot choose from an empty sequence‘) from None
8         return seq[i]```
``` 1 # random.choices
2 def choices(self, population, weights=None, *, cum_weights=None, k=1):
3         """Return a k sized list of population elements chosen with replacement.
4
5         If the relative weights or cumulative weights are not specified,
6         the selections are made with equal probability.
7
8         """
9         random = self.random
10         if cum_weights is None:
11             if weights is None:
12                 _int = int
13                 total = len(population)
14                 return [population[_int(random() * total)] for i in range(k)]
15             cum_weights = list(_itertools.accumulate(weights))
16         elif weights is not None:
17             raise TypeError(‘Cannot specify both weights and cumulative weights‘)
18         if len(cum_weights) != len(population):
19             raise ValueError(‘The number of weights does not match the population‘)
20         bisect = _bisect.bisect
21         total = cum_weights[-1]
22         hi = len(cum_weights) - 1
23         return [population[bisect(cum_weights, random() * total, 0, hi)]
24                 for i in range(k)]```
``` 1 # random.sample
2
3 def sample(self, population, k):
4         """Chooses k unique random elements from a population sequence or set.
5
6         Returns a new list containing elements from the population while
7         leaving the original population unchanged.  The resulting list is
8         in selection order so that all sub-slices will also be valid random
9         samples.  This allows raffle winners (the sample) to be partitioned
10         into grand prize and second place winners (the subslices).
11
12         Members of the population need not be hashable or unique.  If the
13         population contains repeats, then each occurrence is a possible
14         selection in the sample.
15
16         To choose a sample in a range of integers, use range as an argument.
17         This is especially fast and space efficient for sampling from a
18         large population:   sample(range(10000000), 60)
19         """
20
21         # Sampling without replacement entails tracking either potential
22         # selections (the pool) in a list or previous selections in a set.
23
24         # When the number of selections is small compared to the
25         # population, then tracking selections is efficient, requiring
26         # only a small set and an occasional reselection.  For
27         # a larger number of selections, the pool tracking method is
28         # preferred since the list takes less space than the
29         # set and it doesn‘t suffer from frequent reselections.
30
31         if isinstance(population, _Set):
32             population = tuple(population)
33         if not isinstance(population, _Sequence):
34             raise TypeError("Population must be a sequence or set.  For dicts, use list(d).")
35         randbelow = self._randbelow
36         n = len(population)
37         if not 0 <= k <= n:
38             raise ValueError("Sample larger than population or is negative")
39         result = [None] * k
40         setsize = 21        # size of a small set minus size of an empty list
41         if k > 5:
42             setsize += 4 ** _ceil(_log(k * 3, 4)) # table size for big sets
43         if n <= setsize:
44             # An n-length list is smaller than a k-length set
45             pool = list(population)
46             for i in range(k):         # invariant:  non-selected at [0,n-i)
47                 j = randbelow(n-i)
48                 result[i] = pool[j]
49                 pool[j] = pool[n-i-1]   # move non-selected item into vacancy
50         else:
51             selected = set()
53             for i in range(k):
54                 j = randbelow(n)
55                 while j in selected:
56                     j = randbelow(n)
58                 result[i] = population[j]
59         return result```

``` 1 import string
2 import random
3
4 # 方法一
5 seeds = string.digits
6 random_str = []
7 for i in range(4):
8     random_str.append(random.choice(seeds))
9 print("".join(random_str))
10
11 # 方法二
12 seeds = string.digits
13 random_str = random.choices(seeds, k=4)
14 print("".join(random_str))
15
16 # 方法三
17 seeds = string.digits
18 random_str = random.sample(seeds, k=4)
19 print("".join(random_str))```
• 说明一下：string.digits是一个定义好的数字字符串，就是从"0123456789"。
``` 1 """
2 whitespace -- a string containing all ASCII whitespace
3 ascii_lowercase -- a string containing all ASCII lowercase letters
4 ascii_uppercase -- a string containing all ASCII uppercase letters
5 ascii_letters -- a string containing all ASCII letters
6 digits -- a string containing all ASCII decimal digits
7 hexdigits -- a string containing all ASCII hexadecimal digits
8 octdigits -- a string containing all ASCII octal digits
9 punctuation -- a string containing all ASCII punctuation characters
10 printable -- a string containing all ASCII characters considered printable
11 """
12
13 # Some strings for ctype-style character classification
14 whitespace = ‘ \t\n\r\v\f‘
15 ascii_lowercase = ‘abcdefghijklmnopqrstuvwxyz‘
16 ascii_uppercase = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZ‘
17 ascii_letters = ascii_lowercase + ascii_uppercase
18 digits = ‘0123456789‘
19 hexdigits = digits + ‘abcdef‘ + ‘ABCDEF‘
20 octdigits = ‘01234567‘
21 punctuation = r"""!"#\$%&‘()*+,-./:;<=>[email protected][\]^_`{|}~"""
22 printable = digits + ascii_letters + punctuation + whitespace```

python生成四位随机数

(0)
(0)

0条