Python generate file name

Best way to generate random file names in Python

In Python, what is a good, or the best way to generate some random text to prepend to a file(name) that I’m saving to a server, just to make sure it does not overwrite. Thank you!

15 Answers 15

You could use the UUID module for generating a random string:

import uuid filename = str(uuid.uuid4()) 

This is a valid choice, given that an UUID generator is extremely unlikely to produce a duplicate identifier (a file name, in this case):

Only after generating 1 billion UUIDs every second for the next 100 years, the probability of creating just one duplicate would be about 50%. The probability of one duplicate would be about 50% if every person on earth owns 600 million UUIDs.

This is also a useful alternative to NamedTemporaryFile() if you are blocked from privaleges on C drive for e.g. a work computer. This was the case for me but the uuid method worked as it’s just a random string you can save in the local folder

Python has facilities to generate temporary file names, see http://docs.python.org/library/tempfile.html. For instance:

Each call to tempfile.NamedTemporaryFile() results in a different temp file, and its name can be accessed with the .name attribute, e.g.:

In [5]: tf = tempfile.NamedTemporaryFile() In [6]: tf.name Out[6]: 'c:\\blabla\\locals~1\\temp\\tmptecp3i' In [7]: tf = tempfile.NamedTemporaryFile() In [8]: tf.name Out[8]: 'c:\\blabla\\locals~1\\temp\\tmpr8vvme' 

Once you have the unique filename it can be used like any regular file. Note: By default the file will be deleted when it is closed. However, if the delete parameter is False, the file is not automatically deleted.

tempfile.NamedTemporaryFile([mode='w+b'[, bufsize=-1[, suffix=''[, prefix='tmp'[, dir=None[, delete=True]]]]]]) 

it is also possible to specify the prefix for the temporary file (as one of the various parameters that can be supplied during the file creation):

In [9]: tf = tempfile.NamedTemporaryFile(prefix="zz") In [10]: tf.name Out[10]: 'c:\\blabla\\locals~1\\temp\\zzrc3pzk' 

Additional examples for working with temporary files can be found here

The problem with this solution is that it generates not only a file name, but also a file that is already open. If you need a temporary file name for a new, not yet existing file (e.g., to use as output of an os command), this will not do. In that case, you can do something like str(uuid.uuid4()) .

@Luca Thanks for the additional comment, that is useful, and noted for future reference. However, OP clearly stated that he/she wanted to save a file, hence need to open it, so this solution provides for that.

It depends. Perhaps he needs the name to construct an appropriate server call. Not sure. At any rate your reply is certainly the more common case.

a common approach is to add a timestamp as a prefix/suffix to the filename to have some temporal relation to the file. If you need more uniqueness you can still add a random string to this.

import datetime basename = "mylogfile" suffix = datetime.datetime.now().strftime("%y%m%d_%H%M%S") filename = "_".join([basename, suffix]) # e.g. 'mylogfile_120508_171442' 

In a multi-threaded environment, there’s a possible race condition involved in the sequence 1. Test if file exists, 2. create file. If another process interrupts yours between steps 1 and 2, and creates the file, when your code resumes it will overwrite the other process’ file.

@Li-aungYip In addition can also use 6-8 random character sequence (in case 2 files are generated in the same second).

The OP requested to create random filenames not random files. Times and UUIDs can collide. If you are working on a single machine (not a shared filesystem) and your process/thread will not stomp on itself, use os.getpid() to get your own PID and use this as an element of a unique filename. Other processes would obviously not get the same PID. If you are multithreaded, get the thread id. If you have other aspects of your code in which a single thread or process could generate multiple different temp files, you might need to use another technique. A rolling index can work (if you aren’t keeping them so long or using so many files you would worry about rollover). Keeping a global hash/index to «active» files would suffice in that case.

So sorry for the longwinded explanation, but it does depend on your exact usage.

If you need no the file path, but only the random string having predefined length you can use something like this.

>>> import random >>> import string >>> file_name = ''.join(random.choice(string.ascii_lowercase) for i in range(16)) >>> file_name 'ytrvmyhkaxlfaugx' 

If you want to preserve the original filename as a part of the new filename, unique prefixes of uniform length can be generated by using MD5 hashes of the current time:

from hashlib import md5 from time import localtime def add_prefix(filename): prefix = md5(str(localtime()).encode('utf-8')).hexdigest() return f"_" 

Calls to the add_prefix(‘style.css’) generates sequence like:

a38ff35794ae366e442a0606e67035ba_style.css 7a5f8289323b0ebfdbc7c840ad3cb67b_style.css 

To avoid: Unicode-objects must be encoded before hashing I changed to md5(str(localtime()).encode(‘utf-8’)).hexdigest()

Note that a hash of any kind of data (including a timestamp) does not ensure uniqueness by itself (any more than a randomly chosen byte sequence does).

In [19]: tempfile.mkstemp('.png', 'bingo', '/tmp')[1] Out[19]: '/tmp/bingoy6s3_k.png' 

According to the python doc for tempfile.mkstemp, it creates a temporary file in the most secure manner possible. Please note that the file will exist after this call:

In [20]: os.path.exists(tempfile.mkstemp('.png', 'bingo', '/tmp')[1]) Out[20]: True 

As date and time both change after each second so you need to concatenate data-time with uuid (Universally Unique Identifiers) here is the complete code for your answer

 import uuid imageName = '<>.jpeg'.format(str(uuid.uuid4().hex), datetime.now()) 

While this code may solve the question, including an explanation of how and why this solves the problem would really help to improve the quality of your post, and probably result in more up-votes. Remember that you are answering the question for readers in the future, not just the person asking now. Please edit your answer to add explanations and give an indication of what limitations and assumptions apply.

I personally prefer to have my text to not be only random/unique but beautiful as well, that’s why I like the hashids lib, which generates nice looking random text from integers. Can installed through

import hashids hashids = hashids.Hashids(salt="this is my salt", ) print hashids.encode(1, 2, 3) >>> laHquq 

Short Description:

Hashids is a small open-source library that generates short, unique, non-sequential ids from numbers.

>>> import random >>> import string >>> alias = ''.join(random.choice(string.ascii_letters) for _ in range(16)) >>> alias 'WrVkPmjeSOgTmCRG' 

You could change ‘string.ascii_letters’ to any string format as you like to generate any other text, for example mobile NO, ID.

import random def Generate(): #function generates a random 6 digit number code = '' for i in range(6): code += str(random.randint(0,9)) return code print(Generate()+".txt") 

In some other cases if you need the random file name to be sensible, use the faker module. This will produce «sensible» file names with common extension. This method might have name collision after some time. I think prepend with uuid is probably better.

from faker import Faker fake = Faker() for _ in range(10): print(fake.file_name()) 

I found considerable benefit to the following solution.

I needed to store hundreds of thousands of images in a directory on a remote server. There was an issue with space on the server we were using and many of these images would often be duplicates of each other, so I found a handy solution is using the SHA of the image to generate the filename, and store the file using that name. If it overwrites a file, that means that file was a duplicate so it’s okay that it gets overwritten. SHA256 is considered to be physically incapable of producing collisions, so you can use it forever without worry.

import hashlib image_path = '/tmp/my_image.png' with open(image_path, 'rb') as f: image_bytes = f.read() file_name = f'.png' with open(filename, 'wb') as ff: ff.write(image_bytes) 

This method is only useful if the following apply to your situation.

1. You do not care about file creation date.
2. You do not rely on duplicate files for your system to work.
3. You do not need to search through the images using their names (that would suck)

This method will also be of little benefit to you if the files you are saving almost certainly will never produce the same SHA, but it can still be useful if you are saving several thousand files and need to guarantee that none of them overwrite(besides duplicates).

Источник

Python: How to create a unique file name?

I am not sure how to generate a unique file name. Can anybody give me some tips on how to generate a unique file name? Any algorithms, suggestions, and lines of code are appreciated.

I edited your question to try and make it more clear. Let me know if I interpreted something incorrectly!

9 Answers 9

I didn’t think your question was very clear, but if all you need is a unique file name.

import uuid unique_filename = str(uuid.uuid4()) 

uuid seems to create a long unique string. I dont think its better to have file name with long string and UUID, () in it.

@ToloPalmer: It’s more likely that your computer’s CPU has a processing error that causes it to load the wrong file than it is a generated UUID collides with any existing value. UUID produces a unique name in a model of computing that understands not all computation is pure mathematics.

Pardon my ignorance old comment. Indeed is not unique but very unlikely to collide, so good choice 😉

If you want to make temporary files in Python, there’s a module called tempfile in Python’s standard libraries. If you want to launch other programs to operate on the file, use tempfile.mkstemp() to create files, and os.fdopen() to access the file descriptors that mkstemp() gives you.

Incidentally, you say you’re running commands from a Python program? You should almost certainly be using the subprocess module.

So you can quite merrily write code that looks like:

import subprocess import tempfile import os (fd, filename) = tempfile.mkstemp() try: tfile = os.fdopen(fd, "w") tfile.write("Hello, world!\n") tfile.close() subprocess.Popen(["/bin/cat", filename]).wait() finally: os.remove(filename) 

Running that, you should find that the cat command worked perfectly well, but the temporary file was deleted in the finally block. Be aware that you have to delete the temporary file that mkstemp() returns yourself — the library has no way of knowing when you’re done with it!

(Edit: I had presumed that NamedTemporaryFile did exactly what you’re after, but that might not be so convenient — the file gets deleted immediately when the temp file object is closed, and having other processes open the file before you’ve closed it won’t work on some platforms, notably Windows. Sorry, fail on my part.)

Источник