Python: Generate Temporary Files And Directories Using tempfile
Tags: python, tutorial, beginners
Published: 2023-04-06 07:57:03

This article was originally published on [GeekPython](https://geekpython.in)

Python has a rich collection of standard libraries to carry out various tasks. In Python, there is a module called **tempfile** that allows us to create and manipulate temporary files and directories.

We can use tempfile to create temporary files and directories for storing temporary data during the program execution. The module has functions that allow us to create, read, and manipulate temporary files and directories.

In this article, we'll go over the fundamentals of the tempfile module, including creating, reading, and manipulating temporary files and directories, as well as cleaning up after we're done with them.

# Creating temporary file

The tempfile module includes a function called `TemporaryFile()` that allows us to create a temporary file for use as temporary storage. Simply enter the following code to create a temporary file.

```python
import tempfile

# Creating a temporary file
temp_file = tempfile.TemporaryFile()

print(f'Tempfile object: {temp_file}')
print(f'Tempfile name: {temp_file.name}')

# Closing the file 
temp_file.close()
```

First, we imported the module, and because it is part of the standard Python library, we did not need to install it.

Then we used the `TemporaryFile()` function to create a temporary file, which we saved in the `temp_file` variable. Then we added print statements to display the tempfile object and temporary file name.

Finally, we used the `close()` function to close the file, just as we would any other file. This will automatically clean up and delete the file.

**Output**

```bash
Tempfile object: <tempfile._TemporaryFileWrapper object at 0x0000015E54545AE0>
Tempfile name: C:\Users\SACHIN\AppData\Local\Temp\tmp5jyjavv2
```

We got the location of the object in memory when we printed the object `temp_file`, and we got the random name `tmp5jyjavv2` with the entire path when we printed the name of the temporary file.

We can specify `dir` parameter to create a temporary file in the specified directory.

```python
import tempfile

# Creating a temporary file in the cwd
named_file = tempfile.TemporaryFile(
    dir='./'
)

print('File created in the cwd')
print(named_file.name)

# Closing the file
named_file.close()
```

The file will be created in the current working directory.

```bash
File created in the cwd
D:\SACHIN\Pycharm\tempfile_module\tmptbg9u6wk
```

# Writing text and reading it

The `TemporaryFile()` function sets the mode parameter `'w+b'` to the default value to read and write files in a binary mode. We can also use `'w+t'` mode to write text data into the temporary file.

```python
import tempfile

# Creating a temporary file
file = tempfile.TemporaryFile()

try:
    # Writing into the temporary file
    file.write(b"Welcome to GeekPython.")
    # Position to start reading the file
    file.seek(0)  # Reading will start from beginning
    # Reading the file
    data = file.read()
    print(data)
finally:
    # Closing the file
    file.close()

----------
b'Welcome to GeekPython.'
```

In the above code, we created a temporary file and then used the `write()` function to write data into it, passing the string in bytes format (as indicated by the prefix `'b'` before the content).

Then we used the `read()` function to read the content, but first, we specified the position from which to begin reading the content using the `seek(0)` (start from the beginning) function, and finally, we closed the file.

# Using context manager

We can also create temporary files using the context managers such as `with` keyword. Also, the following example will show us how to write and read text data into the temporary file.

```python
import tempfile

# Using with statement creating a temporary file
with tempfile.TemporaryFile(mode='w+t') as file:
    # Writing text data into the file
    file.write('Hello Geeks!')
    # Specifying the position to start reading
    file.seek(0)
    # Reading the content
    print(file.read())
    # Closing the file
    file.close()
```

In the above code, we used the `with` statement to create a temporary file and then opened it in text mode(`'w+t'`) and did everything the same as we do for handling other files in Python.

```bash
Hello Geeks!
```

# Named temporary file

To take more control over making the temporary file like naming the temporary file as we want or keeping it or deleting it, then we can use `NamedTemporaryFile()`.

When creating a temporary file, we can specify a **suffix** and a **prefix**, and we can choose whether to delete or keep the temporary file. It has a `delete` parameter that defaults to `True`, which means that the file will be deleted automatically when we close it, but we can change this value to `False` to keep it.

```python
import tempfile

# Creating a temporary file using NamedTemporaryFile()
named_file = tempfile.NamedTemporaryFile()

print('Named file:', named_file)
print('Named file name:', named_file.name)

# Closing the file
named_file.close()

----------
Named file: <tempfile._TemporaryFileWrapper object at 0x000001E70CDEC310>
Named file name: C:\Users\SACHIN\AppData\Local\Temp\tmpk6ycz_ek
```

The output of the above code is the same as when we created the temporary file using the `TemporaryFile()` function, it's because `NamedTemporaryFile()` operates exactly as `TemporaryFile()` but the temporary file created using the `NamedTemporaryFile()` is guaranteed to have a visible name in the file system.

**How to customize the name of a temporary file?**

As you can see, the name of our temporary file is generated at random, but we can change that with the help of the `prefix` and `suffix` parameters.

```python
import tempfile

# Creating a temporary file using NamedTemporaryFile()
named_file = tempfile.NamedTemporaryFile(
    prefix='geek-',
    suffix='-python'
)

print('Named file name:', named_file.name)

# Closing the file
named_file.close()
```

The temporary file will now be created when the code is run, and its name will be prefixed and suffixed with the values we specified in the code above.

```bash
Named file name: C:\Users\SACHIN\AppData\Local\Temp\geek-n6luwuwx-python
```

# Creating temporary directory

To create a temporary directory, we can use `TemporaryDirectory()` function from the tempfile module.

```python
import tempfile

# Creating a temporary directory inside the TempDir
tempdir = tempfile.TemporaryDirectory(
    dir='TempDir'
)

# Printing the name of temporary dir
print('Temp Directory:', tempdir.name)

# Cleaning up the dir
tempdir.cleanup()
```

The above code will create a temporary directory inside the ***TempDir*** directory that we created in the root directory. Then we printed the name of the temporary directory and then called the `cleanup()` method to explicitly clean the temporary directory.

```python
Temp Directory: TempDir\tmplfu2ooew
```

We can use `with` statement to create a temporary directory and we can also specify `suffix` and `prefix` parameters.

```python
with tempfile.TemporaryDirectory(
        dir='TempDir',
        prefix='hey-',
        suffix='-there'
) as tempdir:
    print("Temp Dir:", tempdir)
```

When we create a temporary directory using the `with` statement the name of the directory will be assigned to the target of the `as` clause. To get the name of the temporary directory, we passed `tempdir` rather than `tempdir.name` in the print statement.

```python
Temp Dir: TempDir\hey-q14i1hc4-there
```

You will notice that this time we didn't use the `cleanup()` method, that's because the temporary directory and its content are removed after the completion of the context of the temporary directory object.

# SpooledTemporaryFile

The `SpooledTemporaryFile()` function is identical to `TemporaryFile()`, with the exception that it stores the data in memory up until the maximum size is reached or `fileno()` method is called.

```python
import tempfile

# Creating a temporary file to spool data into it
sp_file = tempfile.SpooledTemporaryFile(max_size=10)
print(sp_file)

# Writing into the file
sp_file.write(b'Hello from GeekPython')

# Printing the size of the file
print(sp_file.__sizeof__())

# Printing if data is written to the disk
print(sp_file._rolled)
print(sp_file._file)
```

With the `max_size` parameter set to **10**, we used the `SpooledTemporaryFile()` function to create a spooled temporary file. It indicates that file size up to 10 can be stored in the memory before it is rolled over to the on-disk file.

Then we wrote some data into the file and printed the size of the file using the `__sizeof__` attribute.

There is a `rollover()` method by which we can see whether the data is in the memory or rolled over to the on-disk temporary file. This method returns a boolean value, **True** means the data is rolled over and **False** means the data is still in the memory of the spooled temporary file.

```python
<tempfile.SpooledTemporaryFile object at 0x0000023FFBD0C370>
32
True
<tempfile._TemporaryFileWrapper object at 0x0000023FFBD0D930>
```

The temporary file object is **SpooledTemporaryFile**, as can be seen. Because the amount of data we wrote into the file exceeded the allowed size, the data was rolled over, and we received the boolean value `True`.

Depending on the mode we specified, this function returns a file-like object whose `_file` attribute is either an `io.BytesIO` or an `io.TextIOWrapper` (binary or text). Up until the data exceeded the max size, this function holds the data in memory using the `io.BytesIO` or `io.TextIOWrapper` buffer.

```python
import tempfile

with tempfile.SpooledTemporaryFile(mode="w+t", max_size=50) as sp_file:
    print(sp_file)

    # Running a while loop until the data gets rolled over
    while sp_file._rolled == False:
        sp_file.write("Welcome to GeekPython")
        print(sp_file._rolled, sp_file._file)
```

**Output**

```python
<tempfile.SpooledTemporaryFile object at 0x000001A8901CC370>
False <_io.TextIOWrapper encoding='cp1252'>
False <_io.TextIOWrapper encoding='cp1252'>
True <tempfile._TemporaryFileWrapper object at 0x000001A8906388E0>
```

Until the data is rolled over, we ran a `while` loop and printed the `_file` attribute of the `SpooledTemporaryFile` object. As we can see the data was stored in the memory using the `io.TextIOWrapper` buffer(mode was set to text) and when the data was rolled over, the code returned the temporary file object.

**We can do the same with data in binary format.**

```python
import tempfile

with tempfile.SpooledTemporaryFile(mode="w+b", max_size=50) as sp_file:
    print(sp_file)

    # Running a while loop until the data gets rolled over
    while sp_file._rolled == False:
        sp_file.write(b"Welcome to GeekPython")
        print(sp_file._rolled, sp_file._file)
```

**Output**

```python
<tempfile.SpooledTemporaryFile object at 0x00000223C633C370>
False <_io.BytesIO object at 0x00000223C6331580>
False <_io.BytesIO object at 0x00000223C6331580>
True <tempfile._TemporaryFileWrapper object at 0x00000223C67A8850>
```

We can also call `fileno()` to roll over the file content.

```python
import tempfile

with tempfile.SpooledTemporaryFile(mode="w+b", max_size=500) as sp_file:
    print(sp_file)

    for _ in range(3):
        sp_file.write(b'Hey, there welcome')
        print(sp_file._rolled, sp_file._file)

    print('Data is written to the disk before reaching the max size.')
    # Calling the fileno() method
    sp_file.fileno()
    print(sp_file._rolled, sp_file._file)
```

**Output**

```python
<tempfile.SpooledTemporaryFile object at 0x000001F51D12C370>
False <_io.BytesIO object at 0x000001F51D121580>
False <_io.BytesIO object at 0x000001F51D121580>
False <_io.BytesIO object at 0x000001F51D121580>
Data is written to the disk before reaching the max size.
True <tempfile._TemporaryFileWrapper object at 0x000001F51D5A0970>
```

# Low-level functions

There are some low-level functions included in the tempfile module. We'll explore them one by one.

## mkstemp and mkdtemp

`mkstemp` is used for creating a temporary file in the most secure manner possible and `mkdtemp` is used to create a temporary directory in the most secure manner possible.

They also have parameters like `suffix`, `prefix` and `dir` but `mkstemp` has one additional `text` parameter which defaults to `False`(binary mode), if we make it `True` then the file will be opened in text mode.

```python
import tempfile

# Using mkstemp
file = tempfile.mkstemp(prefix='hello-', suffix='-world')
print('Created File:', file)

# Using mkdtemp
directory = tempfile.mkdtemp(dir='TempDir')
print('Directory Created:', directory)

----------
Created File: (3, 'C:\\Users\\SACHIN\\AppData\\Local\\Temp\\hello-xmtqn88f-world')
Directory Created: TempDir\tmp_6coyqq2
```

**Note**: There is a function called `mktemp()` also which is deprecated.

## **gettempdir** and **gettempdirb**

`gettempdir()` is used to return the name of the directory used for temporary files and `gettempdirb()` also return the name of the directory but in bytes.

```python
import tempfile

print(tempfile.gettempdir())
print(tempfile.gettempdirb())

----------
C:\Users\SACHIN\AppData\Local\Temp
b'C:\\Users\\SACHIN\\AppData\\Local\\Temp'
```

# Conclusion

The **tempfile** module, which offers functions to create temporary files and directories, was covered in this article. We have used various functions from the tempfile module in code examples, which has helped us better understand how these functions operate.

---

🏆**Other articles you might be interested in if you liked this one**

✅[Use match case statement for pattern matching in Python](https://geekpython.in/match-case-in-python).

✅[Types of class inheritance in Python with examples](https://geekpython.in/class-inheritance-in-python).

✅[An improved and modern way of string formatting in Python](https://geekpython.in/f-string-in-python).

✅[Integrate PostgreSQL database with Python](https://geekpython.in/integrate-postgresql-database-in-python).

✅[Argmax function in NumPy and TensorFlow - Are they the same](https://geekpython.in/argmax-function-in-numpy-and-tensorflow)?

✅[Take multiple inputs from the user in a single line in Python](https://geekpython.in/multiple-inputs-in-python).

✅[Perform a parallel iteration over multiple iterables using zip() function in Python](https://geekpython.in/zip-function-in-python-usage-and-examples-with-code).

---

**That's all for now**

**Keep Coding✌✌**