How to open files in python

How to Open Files in Python

Python gives us file handling methods within its standard library. This is really convenient as a developer since you do not really need to import any more modules for handling files.

Let’s go over the open() method that allows us to open files in Python in different modes.

Open Files in Python

To open a file, all we need is the directory path that the file is located in. If it’s located in the same directory then including just the complete filename will suffice.

I’ve created a file with some sample text in it which we’ll use as a sample to learn the open file method.

1. Opening a file using the open() method

To open the OpenFile.txt and read the text contents of the file, let’s use the open() and the read() methods.

The read() method will read the entire contents of the file.

By default, the open() method opens a file in read-only mode. To write to a file, we will need to specify that the file has to be opened in write mode.

2. Different Modes For open() Method

Let’s try to write to the file with the default mode on.

We’ll keep the read operation as it is so we can see where the code stops.

So what are modes, and how do we add them? Below is a list of modes when using the open() method.

3. Opening Files in Write Mode in Python

There are multiple ways you can open a file in write mode in Python. Depending on how you want the file handling methods to write to a file, you can use one of the below modes.

By adding the ‘w’ while opening the file in the first line, we specify that the file should be opened in write mode. But this operation would fail too because the file is write-only and won’t allow us to use the read() method.

The above code will completely clear all the contents of the text file and instead just say “New content”.

If you do not want to overwrite the file, you can use the a+ or r+ modes.

The r+ mode will write any content passed to the write() method.

The a or a+ mode will perform the same action as the r+ mode with one main difference.

In the case of the r+ method, a new file will not be created if the filename specified does not exist. But with a+ mode, a new file will be created if the specified file is not available.

4. Opening Files Using the with clause

When reading files with the open() method, you always need to make sure that the close() method is called to avoid memory leaks. As a developer, you could miss out on adding the close() method causing your program to leak file memory due to the file being open.

With smaller files, there isn’t a very noticeable effect on the system resources but it would show up when working with larger files.

In the above example, the output would be the same as the ones we saw in the beginning, but we don’t have to close the file.

A with block acquires a lock as soon as it’s executed and releases the lock once the block ends.

You can also run other methods on the data while staying within the with code block. I’ve edited the OpenFile.txt, in this case, and added some more text for better understanding.

The with statement does the memory handling for us as long as we continue to work within its scope. This is yet another but the better way to work with files in Python.

Conclusion

You should now have a grasp on how to open a file in Python and handle the different modes for opening a file with the open() method. We’ll cover further file handling methods in upcoming tutorials.

7. Input and Output¶

There are several ways to present the output of a program; data can be printed in a human-readable form, or written to a file for future use. This chapter will discuss some of the possibilities.

7.1. Fancier Output Formatting¶

Often you’ll want more control over the formatting of your output than simply printing space-separated values. There are several ways to format output.

The str.format() method of strings requires more manual effort. You’ll still use < and >to mark where a variable will be substituted and can provide detailed formatting directives, but you’ll also need to provide the information to be formatted.

Finally, you can do all the string handling yourself by using string slicing and concatenation operations to create any layout you can imagine. The string type has some methods that perform useful operations for padding strings to a given column width.

When you don’t need fancy output but just want a quick display of some variables for debugging purposes, you can convert any value to a string with the repr() or str() functions.

7.1.1. Formatted String Literals¶

Formatted string literals (also called f-strings for short) let you include the value of Python expressions inside a string by prefixing the string with f or F and writing expressions as .

An optional format specifier can follow the expression. This allows greater control over how the value is formatted. The following example rounds pi to three places after the decimal:

Passing an integer after the ‘:’ will cause that field to be a minimum number of characters wide. This is useful for making columns line up.

7.1.2. The String format() Method¶

Basic usage of the str.format() method looks like this:

The brackets and characters within them (called format fields) are replaced with the objects passed into the str.format() method. A number in the brackets can be used to refer to the position of the object passed into the str.format() method.

If keyword arguments are used in the str.format() method, their values are referred to by using the name of the argument.

Positional and keyword arguments can be arbitrarily combined:

If you have a really long format string that you don’t want to split up, it would be nice if you could reference the variables to be formatted by name instead of by position. This can be done by simply passing the dict and using square brackets ‘[]’ to access the keys.

This could also be done by passing the table dictionary as keyword arguments with the ** notation.

As an example, the following lines produce a tidily aligned set of columns giving integers and their squares and cubes:

7.1.3. Manual String Formatting¶

Here’s the same table of squares and cubes, formatted manually:

(Note that the one space between each column was added by the way print() works: it always adds spaces between its arguments.)

7.1.4. Old string formatting¶

More information can be found in the printf-style String Formatting section.

7.2. Reading and Writing Files¶

The first argument is a string containing the filename. The second argument is another string containing a few characters describing the way in which the file will be used. mode can be ‘r’ when the file will only be read, ‘w’ for only writing (an existing file with the same name will be erased), and ‘a’ opens the file for appending; any data written to the file is automatically added to the end. ‘r+’ opens the file for both reading and writing. The mode argument is optional; ‘r’ will be assumed if it’s omitted.

Normally, files are opened in text mode, that means, you read and write strings from and to the file, which are encoded in a specific encoding. If encoding is not specified, the default is platform dependent (see open() ). Because UTF-8 is the modern de-facto standard, encoding=»utf-8″ is recommended unless you know that you need to use a different encoding. Appending a ‘b’ to the mode opens the file in binary mode. Binary mode data is read and written as bytes objects. You can not specify encoding when opening file in binary mode.

If you’re not using the with keyword, then you should call f.close() to close the file and immediately free up any system resources used by it.

Calling f.write() without using the with keyword or calling f.close() might result in the arguments of f.write() not being completely written to the disk, even if the program exits successfully.

7.2.1. Methods of File Objects¶

The rest of the examples in this section will assume that a file object called f has already been created.

For reading lines from a file, you can loop over the file object. This is memory efficient, fast, and leads to simple code:

f.write(string) writes the contents of string to the file, returning the number of characters written.

Other types of objects need to be converted – either to a string (in text mode) or a bytes object (in binary mode) – before writing them:

f.tell() returns an integer giving the file object’s current position in the file represented as number of bytes from the beginning of the file when in binary mode and an opaque number when in text mode.

File objects have some additional methods, such as isatty() and truncate() which are less frequently used; consult the Library Reference for a complete guide to file objects.

7.2.2. Saving structured data with json В¶

Rather than having users constantly writing and debugging code to save complicated data types to files, Python allows you to use the popular data interchange format called JSON (JavaScript Object Notation). The standard module called json can take Python data hierarchies, and convert them to string representations; this process is called serializing. Reconstructing the data from the string representation is called deserializing. Between serializing and deserializing, the string representing the object may have been stored in a file or data, or sent over a network connection to some distant machine.

The JSON format is commonly used by modern applications to allow for data exchange. Many programmers are already familiar with it, which makes it a good choice for interoperability.

To decode the object again, if f is a binary file or text file object which has been opened for reading:

JSON files must be encoded in UTF-8. Use encoding=»utf-8″ when opening JSON file as a text file for both of reading and writing.

This simple serialization technique can handle lists and dictionaries, but serializing arbitrary class instances in JSON requires a bit of extra effort. The reference for the json module contains an explanation of this.

Open a File in Python

Python provides inbuilt functions for creating, writing, and reading files. There are two types of files that can be handled in Python, normal text files and binary files (written in binary language, 0s, and 1s).

Refer to the below articles to get an idea about the basics of file handling.

Opening a file

Opening a file refers to getting the file ready either for reading or for writing. This can be done using the open() function. This function returns a file object and takes two arguments, one that accepts the file name and another that accepts the mode(Access Mode). Now, the question arises what is the access mode? Access modes govern the type of operations possible in the opened file. It refers to how the file will be used once it’s opened. These modes also define the location of the File Handle in the file. File handle is like a cursor, which defines from where the data has to be read or written in the file. There are 6 access modes in python.

Syntax:

Note: The file should exist in the same directory as the Python script, otherwise full address of the file should be written. If the file is not exist, then an error is generated, that the file does not exist.

Example #1: Opening a file in read mode in Python.

Python File Open

Open a File on the Server

Assume we have the following file, located in the same folder as Python:

To open the file, use the built-in open() function.

The open() function returns a file object, which has a read() method for reading the content of the file:

Example

If the file is located in a different location, you will have to specify the file path, like this:

Example

Open a file on a different location:

Read Only Parts of the File

By default the read() method returns the whole text, but you can also specify how many characters you want to return:

Example

Return the 5 first characters of the file:

Read Lines

You can return one line by using the readline() method:

Example

Read one line of the file:

By calling readline() two times, you can read the two first lines:

Example

Read two lines of the file:

By looping through the lines of the file, you can read the whole file, line by line:

Example

Loop through the file line by line:

Close Files

It is a good practice to always close the file when you are done with it.

Example

Close the file when you are finish with it:

Note: You should always close your files, in some cases, due to buffering, changes made to a file may not show until you close the file.

We just launched
W3Schools videos

COLOR PICKER

Get certified
by completing
a course today!

CODE GAME

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

Thank You For Helping Us!

Your message has been sent to W3Schools.

Top Tutorials

Top References

Top Examples

Web Courses

W3Schools is optimized for learning and training. Examples might be simplified to improve reading and learning. Tutorials, references, and examples are constantly reviewed to avoid errors, but we cannot warrant full correctness of all content. While using W3Schools, you agree to have read and accepted our terms of use, cookie and privacy policy.

Python Read File – How to Open, Read, and Write to Files in Python

Reading and writing files is a common operation when working with any programming language. You can program your code to read data or instructions from a file and then write the data as well. This increases efficiency and reduces manual effort.

Python has a well-defined methodology for opening, reading, and writing files. Some applications for file manipulation in Python include: reading data for algorithm training and testing, reading files to create generative art, reporting, and reading configuration files.

In this tutorial you will learn:

To get quick access to Python IDE, do check out Replit. You can also clone this repo and run it on Replit.

Persistence and How to Load Files into the Main Memory

Files reside in the computer’s secondary memory. Secondary memory is persistent, which means that data is not erased when a computer is powered off. Once you make changes to a file and save it, the changes are permanently written and saved in the secondary memory.

To work with files, we need to load them into the main memory first. Main memory is the temporary cache memory that holds requested data for a brief interval. The data is lost when the computer is powered off.

Files are loaded from secondary memory to the main memory and then processed by the CPU. Once the processing is done, the data is written back to the secondary memory.

Python interacts with files loaded in the main memory through «file handlers«. Let’s look at file handlers in detail.

How File Handlers Work

When we want to read or write a file, we must open it first. Opening a file signals to the operating system to search for the file by its name and ensure that it exists.

The OS returns a file handler if open is successful. Then we can interact with our file through the file handler.

The file handler does not contain the data itself, it just provides an interface for handling the file operations.

A file handler provides your program access to data in the secondary memory.

How to Open a File

Do give the file a look as we will be working with its contents in our upcoming examples.

Example:

In the example above, the OS will return the file handle in the variable fhand if open is successful. By default, you can only read the file.

Output:

The output of a file handle.

In the output, we have received a file handle where name is the file name and mode is the permission which is r (stands for read ) in our case. encoding is the encoding mechanism for the Unicode character set. You can learn more details about UTF-8 here.

Exception:

In case, the file does not exist, we get an exception like this:

Exception when the file is not found.

How to Print the File

Now we have the file handle which means we can access the file. Let’s print the file and see its contents.

Example:

Output:

Printing the contents of a file.

We are able to access and print the file successfully. But, did you notice that we are getting extra blank lines between each line? There is an explanation for this. Let’s see in the next section.

How to Handle Extra Line Spaces

There is a new line character at the end of each line which prints output to the next line. We can visualize it using the repr method.

According to the Python documentation, the repr() method returns a string containing a printable representation of an object. This means that we can see any special character like a \t or a \n that appears in a string.

Let’s run an example below and see the output.

Example:

Back to our file, we can use repr() to check for the special characters.

Output:

Here we can see what’s going on behind the scenes.

Moreover, the print method adds a new line by default. This means that using print, we are getting another new line in the output. We can handle this extra line using two approaches.

Approach #1: Change the default end value of print

Source: Python documentation.

We can change the default value end=’\n’ to a blank so that we do not get a new line at the end of each line. Let’s see the example below to understand better.

Back to our main file, let’s modify the code a bit to get the output without extra blank lines.

Output:

And here we have our desired output!

Approach #2: Use the rstrip() method

We can remove certain characters around a string using the strip() method.

By now we know that by default, every line in a file has «\n» at the end. As we are concerned with only the character on the right, we will use rstrip() which stands for right-strip. We’ll discuss an example of rstrip() next.

You can learn more about the strip() method in this blog post.

How to Let the User Choose a File

Instead of hard coding a filename, we can make the code dynamic by letting the user choose a file.

Let’s ask the user to enter a filename. Then we will calculate the number of lines in the file.

Example:

Ask the user to enter a filename.

Output:

Request the user to enter the file name.

How to Write a File in Python

By default, the file handler opens a file in the read mode. We can write to a file if we open the file with any of the following modes:

How to write to a file

Note that, if we try to open an already existing file with w flag, the contents are overwritten.

How to append to a file

The a flag appends to existing content and preserves the existing content.

How to create a file and write to it

The x mode creates a file and adds content to it.

If the file exists, we’ll get an exception like this:

Exception Handling

It is possible that the file we request does not exist. This blows up the program due to the exception:

In order to make the program more user friendly, we can handle this exception in a try-except block.

The risky part of the program that is expected to blow up is written in a try block. In case the code executes without exception, the except block is skipped and the program continues to run. In case an exception is found, the except block runs and closes the program gracefully with the exit command.

Output:

Exception handling using a try-except block.

Wrapping up

Knowing how to work with files is an essential concept in programming. In this tutorial, you learned how to open files for reading and writing in Python using file handlers.

For reference, I have included all the code snippets and sample files in this GitHub repo.

I hope you found this tutorial helpful.

What’s your favorite thing you learned from this tutorial? Let me know on Twitter!