Using the NumPy Random Number Generator

Random Numbers

If you’re happy to let NumPy perform all of your random number generation work for you, you can use its default values. In other words, your BitGenerator will use PCG64 with a seed from the computer’s clock. To facilitate the defaults, NumPy provides a very handy default_rng() function. This sets everything up for you and returns a reference to a Generator object for you to use to produce random numbers using its range of powerful methods.

To begin with, this code generates a floating-point number using NumPy’s defaults:

>>> import numpy as np

>>> default_rng = np.random.default_rng()
>>> default_rng
'Generator(PCG64) at 0x1E9F2ABBF20'

>>> default_rng.random()
0.47418635476614734

As you can see, BitGenerator uses PCG64. To actually generate a pseudo-random number, you call the generator’s .random() method. To satisfy yourself that the code is indeed generating a random number, run it several times and notice that you get a different number each time. Remember, this is because the seed value passed will be different.

By default, Generator.random() returns a 64-bit float in the half-open interval [0.0, 1.0). This notation is used to define a number range. The [ is the closed parameter and indicates inclusivity. In this example, 0.0 could be one of the numbers randomly generated. The ) is the open parameter and indicates the value 1.0 is just beyond what could be generated. In other words, [0.0, 1.0) defines the range 0.0 ≤ x < 1.0.

>>> from numpy.random import Generator, PCG64DXSM
>>> pcg64dxsm_rng = Generator(PCG64DXSM())
>>> pcg64dxsm_rng.random()
0.3472568589560456

Earlier you learned how passing a seed value determines the sequence of random numbers generated. Recall that passing identical seed values into separate BitGenerator objects forces them to produce the same output. In the following example, you’ll see this for yourself.

In the code snippet below, you seed two separate identical Generator objects, both with a seed value of 100:

>>> rng1 = np.random.default_rng(seed=100)
>>> rng1.random()
0.7852902058808499
>>> rng1.random()
0.7142492625022044

>>> rng2 = np.random.default_rng(seed=100)
>>> rng2.random()
0.7852902058808499
>>> rng2.random()
0.7142492625022044

As expected, each Generator has generated two numbers, but they’re actually pseudo-random numbers! As you can see, the results give you a feeling of déjà vu. Seeding Generator objects identically always produces identical results! It doesn’t matter if both use the default PCG64 or both use the updated PCG64DXSM. The results would still be identical.

The random() method also includes a dtype parameter, which is rarely used. By default, this is set to np.float64, which generates 64-bit floats. If you set this parameter to np.float32, you can generate 32-bit floats instead.

Random Floating-Point Numbers

You already know the .random() method will happily generate random floating-point numbers in the range [0.0, 1.0). Suppose you want to specify your own range. Unfortunately, this isn’t directly possible with .random(), unless you start adding some arithmetic to its output. To specify a range of floats, you can use the .uniform() method.

As you can probably guess from the .uniform() method’s signature, it defaults to generating a floating-point number in the same way that .random() does. However, unlike with .random(), you can optionally specify your own low and high parameters. The .uniform() method also contains a size parameter. You’ll learn more about this when you learn to generate random NumPy arrays later.

In its most basic form, you can call the .uniform() method with no parameters:

>>> import numpy as np
>>> rng = np.random.default_rng()

>>> rng.uniform()
0.5425301829704396

When you run the above code,.uniform() will generate a single random floating-point number in the range [0, 1). In other words, the lowest number will be 0, while the largest number will be just less than 1. Should you want a number from 0 to just before 10, for example, you’d need to multiply the output by 10. However, this is limited because the lower bound will always be zero, and the coding is unclear.

A far better way is to utilize the real power of .uniform() by passing in its low and high parameters:

>>> rng.uniform(low=3.4, high=5.6)
4.656018709365851

Here, because you set low=3.4 and high=5.6, the .uniform() method generates another single float, but this time in the range [3.4, 5.6). Again, remember, 3.4 is inclusive, while 5.6 is exclusive.

You may wonder why a method used to generate floats is called .uniform(). The .uniform() method draws its numbers randomly from a uniform probability distribution. A uniform probability distribution means each of the values in the specified range [low, high) has an equal chance of being chosen. You’ll see later that this isn’t the only type of probability distribution NumPy supports.

Random Integer Numbers

If you need to, you can also generate random integers. You do this using the Generator object’s .integers() method.

In its most basic form, you use .integers() with its one mandatory parameter:

>>> import numpy as np

>>> rng = np.random.default_rng()
>>> for i in range(5):
...     rng.integers(3)
...
1
2
0
1
2

When you call .integers() with a single parameter, that parameter defines the upper exclusive bound of the numbers generated. In this example, because you’ve passed in 3, the possibe outputs are in the range [0, 3). In other words, you might get 0, 1, or 2.

If you call .integers() five times using a for loop and the range() function, then it produces five values.

While you might find the above example your most common way of using .integers(), the method is actually far more flexible. Unfortunately, it’s also a little confusing. The .integers() method’s signature includes three parameters for defining the range of numbers from which the method will generate your random numbers: low, high, and endpoint. Unfortunately, they aren’t quite as intuitive to use as their names suggest.

The low parameter is the only one that’s mandatory. While its name suggests its value will define the lowest integer that the .integers() function can select, this is actually only true if you provide a value for the high parameter as well. So if you set low=1 and high=4, then the .integers() method will select a random number in the range [1, 4):

>>> for count in range(5):
...     rng.integers(low=1, high=4)
...
3
2
3
1
2

Here, you’ve only generated the numbers 1, 2, and 3. Once again, while low is possible, high isn’t.

Now, here’s where confusion may occur. If you pass only a low argument and accept the default high value of None, then .integers() sets its low parameter to 0 and use the value you provide for the upper limit. So, for example, if you call .integers(low=7) or .integers(7), although 7 is the low parameter, the method will return a value in the range [0, 7):

>>> for count in range(5):
...     rng.integers(low=7)
...
3
4
2
6
0

In the above code, you generate integers in the range from 0 to 6. Naming low here is misleading. Instead you should call rng.integers(7) or use the more explicit rng.integers(low=0, high=7) to do the same thing. In general, you should always include high if you pass low as a keyword argument.

The third parameter that defines the range is the endpoint parameter, which determines whether the interval includes the high value. Remember how the default is a half-open interval? That’s because endpoint defaults to False, meaning the sample interval is [low, high). However, if you set it to True, then the interval becomes inclusive at both ends, [low, high]. Knowing this, you can now write an inclusive interval:

>>> for count in range(5):
...     rng.integers(low=1, high=4, endpoint=True)
...
1
4
4
3
2

>>> for count in range(5):
...     rng.integers(7, endpoint=True)
...
5
7
6
2
0

This time, the first loop will generate either 1, 2, 3, or 4. The second loop will generate numbers in the range 0 to 7, inclusive. Setting endpoint=True might make your integer intervals more intuitive.

The .integers() method produces 64-bit integers by default. This is because its dtype parameter is set to np.int64. If you set dtype to np.int32, then you’d obtain 32-bit integers instead.

Random NumPy Arrays

When working with NumPy, you may wish to produce a NumPy array containing random numbers. You do this using the size parameter of either the .random(), .uniform(), or .integers() method of the Generator object. In all three methods, the default value of size is None, which causes a single number to be generated. However, if you assign a tuple to size, then you’ll generate an array.

In the example below, you generate a variety of NumPy arrays using different-size tuples:

>>> import numpy as np

>>> rng = np.random.default_rng()

>>> rng.random(size=(5,))
array([0.18097689, 0.19402707, 0.82936953, 0.29470017, 0.73697751])

>>> rng.random(size=(5, 3))
array([[0.85815152, 0.44158512, 0.49992378],
       [0.99656444, 0.40376014, 0.93886646],
       [0.31424733, 0.23561498, 0.43465744],
       [0.02478389, 0.60644643, 0.52940267],
       [0.54349223, 0.77175087, 0.2834884 ]])

>>> rng.random(size=(3, 4, 2))
array([[[0.78538958, 0.93149463],
        [0.73405027, 0.32193268],
        [0.14362809, 0.59825765],
        [0.07675847, 0.0434828 ]],

       [[0.28681395, 0.66925531],
        [0.59575724, 0.18366003],
        [0.54722312, 0.02620217],
        [0.06019602, 0.48735061]],

       [[0.40764258, 0.00756601],
        [0.32556725, 0.44165999],
        [0.05679186, 0.01690106],
        [0.87091753, 0.46327738]]])

If you want to create a one-dimensional array, then you set the size parameter to an integer or a tuple with a single element. Either size=x or size=(x, ) allows you to generate a one-dimensional array with x elements.

Similarly, if you want to create a two-dimensional array with x rows and y columns, then you use size=(x, y). Setting the size parameter to a tuple with the elements (x, y, z) allows you to generate a three-dimensional array with x sets of y rows and z columns.

In this next example, you randomly generate two arrays, but this time, you specify the acceptable ranges of numbers:

>>> rng = np.random.default_rng()
>>> rng.integers(size=(2, 3), low=1, high=5)
array([[4, 2, 3],
       [1, 1, 2]], dtype=int64)

>>> rng.uniform(size=(2, 3), low=1, high=5)
array([[4.97441068, 1.02042664, 1.43584549],
       [2.87965746, 1.99063036, 2.86212453]])

As you can see, the first array contains integers, while the second one contains floating-point numbers. Both are in the range [1, 5).

Now that you’ve gained confidence in creating random integers and floats, both individually and in NumPy arrays, you’ll next see how you can randomize NumPy arrays themselves.

Selecting Array Elements Randomly

Suppose you have a NumPy array of data collected from a survey, and you wish to use a random sample of its elements for analysis. The Generator object’s .choice() method allows you to select random samples from a given array in a variety of different ways. You give this a whirl in the next few examples:

>>> import numpy as np

>>> rng = np.random.default_rng()

>>> input_array_1d = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
>>> rng.choice(input_array_1d, size=3, replace=False)
array([ 6, 12, 10])

>>> rng.choice(input_array_1d, size=(2, 3), replace=False)
array([[ 8, 12, 11],
       [10,  7,  5]])

In this example, you’re analyzing a one-dimensional NumPy array. The first .choice() call creates a one-dimensional array containing three elements chosen randomly from the original array. The second .choice() call creates a two-by-three array of six random elements from the original data.

The previous code makes use of the replace parameter. If you set replace to False, then you can’t select the same element more than once. By default, it’s set to True, meaning the same element might be selected multiple times. This is analogous to selecting a ball from a bag, replacing it, and then selecting again. When you need to avoid duplication, you should set replace to False.

One point to note is that the .choice() method selects elements based on their position in the original array. Should the same value appear twice in the original data, you could end up having both values selected regardless of which replace parameter setting you use.

Selecting Rows and Columns Randomly

Suppose you wanted to randomly select one or more entire rows or columns from an array. The .choice() method allows this by means of its axis parameter. The axis parameter allows you to specify the direction in which you wish to analyze. For a two-dimensional array, setting axis=0, which is the default, means that you’ll be analyzing by row, while setting axis=1 means that you’ll analyze by column.

Here are some examples of random selection in both directions:

>>> import numpy as np

>>> rng = np.random.default_rng()

>>> input_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])

>>> rng.choice(input_array, size=2)
array([[10, 11, 12],
       [10, 11, 12]])

>>> rng.choice(input_array, size=2, axis=1)
array([[ 2,  1],
       [ 5,  4],
       [ 8,  7],
       [11, 10]])

You’re using an original NumPy array with four rows and three columns. The first analysis will randomly select two unique rows. In this case, the same row has been selected twice, but this won’t always be the case. As you might expect, the output is a two-by-three NumPy array. The second analysis randomly selects two columns. Again, duplicates may occur when you run the code, but you haven’t gotten any on this occasion.

To prevent the possibility of the same row or column being chosen multiple times, you set the replace parameter of .choice() to False, rather than its default value of True:

>>> rng.choice(input_array, size=3, replace=False)
array([[10, 11, 12],
       [ 1,  2,  3],
       [ 4,  5,  6]])

You can run the above code as many times as you wish, and you’ll never see any row—or column if axis was set to 1—more than once!

The .choice() method also contains a shuffle parameter that adds in an extra layer of randomness. It allows entire rows—or columns if axis=1—to be reordered after their initial random selection. Individual element order will remain the same within each row or column.

For shuffle to have an effect, you must first set replace to False. That effectively makes the shuffling operation available, but only if shuffle is at its default of True. If you set shuffle to False or set replace to True, then the additional shuffling operation doesn’t occur. In the next few examples, you’ll explore the effects of changing replace and shuffle. Pay careful attention to the output data and its order:

>>> rng = np.random.default_rng(seed=100)
>>> rng.choice(input_array, size=3, replace=False, shuffle=False)
array([[4, 5, 6],
       [7, 8, 9],
       [1, 2, 3]])

As the output above shows, you’ve selected three rows from the array. These have been displayed in their selected order. Setting shuffle to False removes the extra shuffle operation that NumPy otherwise does by default, so you’ve sped up your code. Although replace made shuffling a possibility, setting shuffle to False prevented it from occurring.

To add more randomization, you can keep the default by omitting shuffle, or set shuffle to True explicitly:

>>> rng = np.random.default_rng(seed=100)
>>> rng.choice(input_array, size=3, replace=False, shuffle=True)
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

This time, the same three rows were selected because the same seed value was used, but the shuffle parameter has reordered them. By setting shuffle to True, you’ve shuffled the output.

Try running the previous code repeatedly, and you’ll find that the output each time is identical. Not only is the original row selection pseudo-random, but the subsequent shuffling is pseudo-random as well! Both are based on the seed.

Now if you set replace to True, effectively switching shuffle off, then you’re in for a surprise:

>>> rng = np.random.default_rng(seed=100)
>>> rng.choice(input_array, size=3, replace=True, shuffle=False)
array([[10, 11, 12],
       [10, 11, 12],
       [ 1,  2,  3]])

>>> rng = np.random.default_rng(seed=100)
>>> rng.choice(input_array, size=3, replace=True, shuffle=True)
array([[10, 11, 12],
       [10, 11, 12],
       [ 1,  2,  3]])

When you run the code this time, both outputs are identical. This is because both seed values are identical, and shuffle only has an effect if replace is set to False. However, the selected rows are different from those selected in the previous code, despite the fact that the seed values have remained the same.

Remember, the seed value that you explicitly provide to a PRNG is actually only the number it uses to calculate its real seed. In this case, the value of the replace parameter contributes to the calculation.

Shuffling Arrays Randomly

It’s possible for you to randomize the order of the elements in a NumPy array by using the Generator object’s .shuffle() method. Although you can reach for it in several use cases, a very common application is a card game simulation.

To begin with, you create a function that produces a NumPy array of concatenated strings representing the various cards in a deck, albeit without the jokers:

>>> import numpy as np

>>> def create_deck():
...     RANKS = "2 3 4 5 6 7 8 9 10 J Q K A".split()
...     SUITS = "♣ ♢ ♡ ♠".split()
...     return np.array([r + s for s in SUITS for r in RANKS])
...
>>> create_deck()
array(['2♣', '3♣', '4♣', '5♣', '6♣', '7♣', '8♣', '9♣', '10♣', 'J♣', 'Q♣',
       'K♣', 'A♣', '2♢', '3♢', '4♢', '5♢', '6♢', '7♢', ...,
       '7♠', '8♠', '9♠', '10♠', 'J♠', 'Q♠', 'K♠', 'A♠'], dtype='<U3')

The create_deck() function returns a NumPy array containing strings such as "2♣", "3♢", "8♡", and "K♠". As you can see, it does this by defining two constants containing the card ranks and their suits, and then it uses a list comprehension to create a Python list, which is then converted into a NumPy array.

Now suppose you want to draw three cards randomly from the deck after a shuffle. The .shuffle() method allows you to modify an array in place by shuffling its contents. By performing the shuffle in place, you save valuable memory space:

>>> rng = np.random.default_rng()
>>> deck_of_cards = create_deck()

>>> rng.shuffle(deck_of_cards)
>>> deck_of_cards[0:3]
array(['4♡', '6♠', '2♠'], dtype='<U3')

>>> rng.shuffle(deck_of_cards)
>>> deck_of_cards[0:3]
array(['K♠', '2♣', '6♠'], dtype='<U3')

Your code shuffles the Numpy array card deck and then displays the first three elements—that is, the top three cards—from the shuffled version. You then reshuffle the deck and draw the top three cards again. Well done if you noticed that you performed both shuffles on the complete deck!

Although you could’ve used the .choice() method that you learned about earlier to select the cards, the .shuffle() method is a better option because it actually randomizes the array elements in place. This saves memory.

Reordering Arrays Randomly

Previously, you learned how to select entire rows or columns of a NumPy array at random. Now suppose you wanted to randomize the elements of a multidimensional array. The generator offers .shuffle() that you’ve seen already, as well as the .permutation() and .permuted() methods for this purpose.

The .permutation() method randomly rearranges entire rows or columns. In other words, the elements within each row or column will stay in those rows and columns, but their order will be changed.

To illustrate these methods, you’ll use an altered version of your create_deck() function:

>>> import numpy as np

>>> def create_high_cards():
...     HIGH_CARDS = "10 J Q K A".split()
...     SUITS = "♣ ♢ ♡ ♠".split()
...     return np.array([r + s for s in SUITS for r in HIGH_CARDS])
...

This time, you produce a deck containing only the tens, aces, and faces. This will make the results of the next few examples easier for you to see.

The initial deck looks like this:

>>> NUMBER_OF_SUITS = 4
>>> NUMBER_OF_RANKS = 5
>>> high_deck = create_high_cards().reshape((NUMBER_OF_SUITS, NUMBER_OF_RANKS))
>>> high_deck
array([['10♣', 'J♣', 'Q♣', 'K♣', 'A♣'],
       ['10♢', 'J♢', 'Q♢', 'K♢', 'A♢'],
       ['10♡', 'J♡', 'Q♡', 'K♡', 'A♡'],
       ['10♠', 'J♠', 'Q♠', 'K♠', 'A♠']], dtype='<U3')

As you can see, the suit order is ♣, ♢, ♡, and ♠, in ascending order from ten to ace.

Now you want to organize the cards from each suit in a random order. To do this, you randomize the position of the rows within the array:

>>> NUMBER_OF_SUITS = 4
>>> NUMBER_OF_RANKS = 5
>>> high_deck = create_high_cards().reshape((NUMBER_OF_SUITS, NUMBER_OF_RANKS))

>>> rng = np.random.default_rng()
>>> rng.permutation(high_deck, axis=0)
array([['10♡', 'J♡', 'Q♡', 'K♡', 'A♡'],
       ['10♢', 'J♢', 'Q♢', 'K♢', 'A♢'],
       ['10♣', 'J♣', 'Q♣', 'K♣', 'A♣'],
       ['10♠', 'J♠', 'Q♠', 'K♠', 'A♠']], dtype='<U3')

>>> rng.permutation(high_deck, axis=0)
array([['10♢', 'J♢', 'Q♢', 'K♢', 'A♢'],
       ['10♠', 'J♠', 'Q♠', 'K♠', 'A♠'],
       ['10♡', 'J♡', 'Q♡', 'K♡', 'A♡'],
       ['10♣', 'J♣', 'Q♣', 'K♣', 'A♣']], dtype='<U3')

You populate the initial array using your new create_high_deck() function. This time, you reshape the array into four rows of suits and five columns of card ranks. Then the .permutation() method works row-wise because axis=0. It randomizes the position of each row, but the content of each row remains in its original order.

Also note that the original high_deck is untouched. The previous operations randomized copies of the deck:

>>> high_deck
array([['10♣', 'J♣', 'Q♣', 'K♣', 'A♣'],
       ['10♢', 'J♢', 'Q♢', 'K♢', 'A♢'],
       ['10♡', 'J♡', 'Q♡', 'K♡', 'A♡'],
       ['10♠', 'J♠', 'Q♠', 'K♠', 'A♠']], dtype='<U3')

The suits are still in the original order. Now say you want to organize the cards from each value in a random order. To do this, you randomize the position of the columns:

>>> rng.permutation(high_deck, axis=1)
array([['10♣', 'Q♣', 'A♣', 'J♣', 'K♣'],
       ['10♢', 'Q♢', 'A♢', 'J♢', 'K♢'],
       ['10♡', 'Q♡', 'A♡', 'J♡', 'K♡'],
       ['10♠', 'Q♠', 'A♠', 'J♠', 'K♠']], dtype='<U3')

>>> rng.permutation(high_deck, axis=1)
array([['Q♣', 'K♣', 'J♣', 'A♣', '10♣'],
       ['Q♢', 'K♢', 'J♢', 'A♢', '10♢'],
       ['Q♡', 'K♡', 'J♡', 'A♡', '10♡'],
       ['Q♠', 'K♠', 'J♠', 'A♠', '10♠']], dtype='<U3')

In the above code, the .permutation() method works column-wise because axis=1. This time, you’ve randomized the position of each column with .permutation(), but the content of each column remains in the initial order. As you can see, the queens have taken the place of the ten rank as the first column, but you’ll notice that the suits are in the same, original order. That’s because you’ve rearranged the columns but kept the rows intact.

>>> NUMBER_OF_SUITS = 4
>>> NUMBER_OF_RANKS = 5
>>> high_deck = create_high_cards().reshape((NUMBER_OF_SUITS, NUMBER_OF_RANKS))

>>> rng = np.random.default_rng()
>>> rng.shuffle(high_deck, axis=0)
>>> high_deck
array([['10♢', 'J♢', 'Q♢', 'K♢', 'A♢'],
       ['10♠', 'J♠', 'Q♠', 'K♠', 'A♠'],
       ['10♡', 'J♡', 'Q♡', 'K♡', 'A♡'],
       ['10♣', 'J♣', 'Q♣', 'K♣', 'A♣']], dtype='<U3')

>>> rng.shuffle(high_deck, axis=1)
>>> high_deck
array([['J♢', 'A♢', 'K♢', '10♢', 'Q♢'],
       ['J♠', 'A♠', 'K♠', '10♠', 'Q♠'],
       ['J♡', 'A♡', 'K♡', '10♡', 'Q♡'],
       ['J♣', 'A♣', 'K♣', '10♣', 'Q♣']], dtype='<U3')

The .permuted() method randomizes row or column elements independently of the other rows or columns and places the result into a new array. This is best seen by example.

Suppose you wanted to mix up the rows:

>>> NUMBER_OF_SUITS = 4
>>> NUMBER_OF_RANKS = 5
>>> high_deck = create_high_cards().reshape((NUMBER_OF_SUITS, NUMBER_OF_RANKS))

>>> rng = np.random.default_rng()
>>> rng.permuted(high_deck, axis=0)
array([['10♡', 'J♠', 'Q♠', 'K♠', 'A♠'],
       ['10♢', 'J♣', 'Q♡', 'K♣', 'A♣'],
       ['10♣', 'J♡', 'Q♣', 'K♢', 'A♡'],
       ['10♠', 'J♢', 'Q♢', 'K♡', 'A♢']], dtype='<U3')

The .permuted() method works row-wise (axis=0) on the original array. In other words, it changes the content in each row independently of the other rows. Practically, this means that it randomly rearranges the elements of each column. Each column still contains the same cards, but their order is randomized. As a result, the rows contain different suits. In other words, you’ve randomly shuffled all of the value cards.

As you’ve probably guessed, you could also mix up the columns:

>>> rng.permuted(high_deck, axis=1)
array([['J♣', 'A♣', '10♣', 'Q♣', 'K♣'],
       ['K♢', 'A♢', 'J♢', 'Q♢', '10♢'],
       ['J♡', 'K♡', '10♡', 'Q♡', 'A♡'],
       ['J♠', 'Q♠', 'A♠', '10♠', 'K♠']], dtype='<U3')

This time, you’re working column-wise (axis=1) on the original array. Now you’re changing the content in each column independently of the other columns. Practically, you’re randomly rearranging the elements of each row. Each row still contains the same cards, but their order is randomized. As a result, the columns contain different suits. In other words, you’ve randomly shuffled the same-suit cards.

Finally, suppose you wanted to completely randomize the deck:

>>> rng.permuted(rng.permuted(high_deck, axis=1), axis=0)
array([['A♡', 'Q♡', 'A♢', 'K♡', 'J♡'],
       ['Q♢', 'Q♠', '10♡', 'J♠', 'K♣'],
       ['10♠', 'J♣', 'K♠', 'A♣', 'K♢'],
       ['Q♣', 'J♢', '10♣', '10♢', 'A♠']], dtype='<U3')

To perform a complete shuffle, you call the .permuted() method twice—first row-wise and then column-wise. As a result, you’ve randomized all the elements. This time, you’ve shuffled the entire deck, so it’s ready for dealing. Also note that you could alternatively use rng.permuted(rng.permuted(high_cards, axis=0), axis=1). This would still randomize everything to the same level.