Question: I have:

```
points <- read_xlsx ("Data / PC-2021050200.xlsx", sheet = "coordinate")

```

Earlier in the code, I put the date "2021-05-02" which is a variable.
How to enter date as a variable in the file path?

Answer: 
With regard to your recent replies, might I suggest you not worry too much about the collisions and take an approach such as this:

```
import random
import string
string_set = set()
# Just digits at chars is 36 possibilities
chars = string.digits + string.ascii_uppercase

# For an 8 character string note that there are 36^8 possibilities
N = 8
gen_str = lambda: ''.join(random.choices(chars, k=N))
# This is about 3000,000,000,000 possibilities

# Let's create some strings
for i in range(10000000):
    chars = gen_str()
    # Python set implemented as hash table so this is O(1). (It doesn't slow down as set grows)
    while chars in string_set:
        #Regenerate random number if collision
        #(This is has a n / (36^6) likelihood of happening where "n" is the number of elements in the set so far). Until you exceed 1 billion elements this is a non-issue
        chars = gen_str()
    print("adding to set: ", chars)
    string_set.add(chars)

```

The primary downside of this approach is you'll need to store your set somewhere (pickle and unpickle it) and this will presumably double your memory usage for each 8-char stored in the database. This will also become impossible if your set is too large for your system memory in which case your could look into the "shelve" module which provides a dict-like database object which you can use in basically the same way as a set by ignoring the values stored to each key.
You can use this to create unique combinations:

```
from itertools import permutations
alphabet = '0123456789abcdefghijklmnopqrstuvwxyz'
permutations(alphabet, 8)

```

If you want to draw random but continuously increasing numbers from all possible but unique entries you could try this:

```
# Get maximum of possible entries:
from functools import reduce
import operator
import math

counts = [8,36]
permuations = int(math.factorial(sum(counts))/reduce(operator.mul, map(math.factorial, counts), 1))

# Generate all possible entries (generator)
from itertools import permutations, islice
alphabet = '0123456789abcdefghijklmnopqrstuvwxyz'
g = permutations(alphabet, 8)

# select a list of random indexes to retrieve
from random import sample, seed
n = 5
seed(101)
lst = sorted(sample(range(0, permuations), 5))

# print 5 values from the original generator based on the random indexes
for i in lst:
    print(next(islice(g, i, None)))

```

Essentially you create all possible permutations (unique combinations) then you create a list of random but unique index. Now you order the index, which is why the outcome will always be increasing. Then you match the index by their coresponding value of all possible permutations.