{"id":2652,"date":"2026-10-20T10:56:49","date_gmt":"2026-10-20T10:56:49","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2652"},"modified":"2026-10-21T10:11:28","modified_gmt":"2026-10-21T10:11:28","slug":"file-handling-in-python-tutorial","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-file-handling\/file-handling-in-python-tutorial\/","title":{"rendered":"File Handling in Python"},"content":{"rendered":"

File Handling in Python Tutorial: Open, Read, Write and Append<\/b><\/strong><\/h1>\n

Every variable in your program lives in memory, and memory is wiped the moment the program ends. A user fills in a form, a script calculates a result, a game records a high score, and when the window closes, all of it is gone. To keep anything, a program has to write it to a file.<\/p>\n

File handling is how Python reads from files and writes to them. It lets you store results, load data, keep logs, and share information between programs. A text file of customer names, a CSV of sales, a log of errors and a saved configuration are all handled the same way. Once you know the basic steps, you can work with any of them.<\/p>\n

In this tutorial, we cover the open function and its modes, and then read, readline and readlines, write, append, close and the with statement. We go on to binary files, moving around a file with seek and tell, renaming and deleting files, checking if a file exists, and the errors you will meet. Every example was run on Python 3.13, and the real output is shown. We end with the mistakes beginners make most often and a quick reference.<\/p>\n

What is File Handling in Python?<\/h2>\n

File handling means creating, opening, reading, writing, changing and closing files from inside a Python program. A file stores data on your disk, so it stays after the program stops, and the next run of the program can read it back.<\/p>\n

How Python Handles Files<\/h3>\n

Every file operation follows the same three steps.<\/p>\n

    \n
  1. Open<\/strong> the file, which gives you a file object. You say which file, and what you want to do with it.<\/li>\n
  2. Work<\/strong> on it. Read from it, write to it, or move around inside it.<\/li>\n
  3. Close<\/strong> it, so the data is saved and the file is released for other programs.<\/li>\n<\/ol>\n

    The file object is the link between your program and the file on disk. All the methods in this tutorial, such as read<\/code> and write<\/code>, belong to it.<\/p>\n

    Python File Handling Operations<\/h2>\n

    Use of open()<\/h3>\n

    The open<\/code> function opens a file and returns a file object. Its basic form looks like this:<\/p>\n

    \n
    python<\/div>\n
    file_object = open(file_name, mode, buffering)<\/pre>\n<\/div>\n
    The name file_object<\/code> is just a variable, so it is written with an underscore. Only the first argument is required.<\/p>\n
    \n\n\n\n\n\n\n\n
    Arguments of open<\/caption>\n
    Argument<\/th>\nWhat it means<\/th>\n<\/tr>\n<\/thead>\n
    file_name<\/th>\nThe name or path of the file, as text, such as “test.txt”<\/td>\n<\/tr>\n
    mode<\/th>\nA short text that says what you want to do, such as “r” to read. The default is “r”<\/td>\n<\/tr>\n
    buffering<\/th>\nOptional. The default is minus 1, which means the system chooses. A value of 0 turns buffering off, and that is only allowed for binary files<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    The mode is text, and the default for buffering is minus 1. In text mode, a value of 0 gives this error:<\/p>\n
    \n
    python<\/div>\n
    try:\r\n    open(\"test.txt\", \"w\", 0)\r\nexcept ValueError as e:\r\n    print(\"ValueError:\", e)<\/pre>\n
    output<\/div>\n
    ValueError: can't have unbuffered text I\/O<\/pre>\n<\/div>\n
    Modes for Opening a File<\/h3>\n
    The mode decides what you can do with the file, and what happens if it exists or does not. Four letters set the main action, and one more adds detail.<\/p>\n
    \n\n\n\n\n\n\n\n\n\n
    File modes<\/caption>\n
    Mode<\/th>\nName<\/th>\nWhat it does<\/th>\nIf the file is missing<\/th>\n<\/tr>\n<\/thead>\n
    “r”<\/th>\nRead<\/td>\nOpens for reading. This is the default<\/td>\nFileNotFoundError<\/td>\n<\/tr>\n
    “w”<\/th>\nWrite<\/td>\nOpens for writing and erases the old content<\/td>\nCreates the file<\/td>\n<\/tr>\n
    “a”<\/th>\nAppend<\/td>\nOpens for writing at the end, and keeps the old content<\/td>\nCreates the file<\/td>\n<\/tr>\n
    “x”<\/th>\nCreate<\/td>\nCreates a new file for writing<\/td>\nCreates the file. If it already exists, raises FileExistsError<\/td>\n<\/tr>\n
    “r+”<\/th>\nRead and write<\/td>\nReads and writes, without erasing<\/td>\nFileNotFoundError<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    Two more letters can be added to any of these.<\/p>\n
    \n\n\n\n\n\n\n
    Text and binary letters<\/caption>\n
    Letter<\/th>\nName<\/th>\nWhat it does<\/th>\n<\/tr>\n<\/thead>\n
    t<\/th>\nText<\/td>\nWorks with text. This is the default, so “r” and “rt” are the same<\/td>\n<\/tr>\n
    b<\/th>\nBinary<\/td>\nWorks with raw bytes, as in images and PDFs. Used as “rb”, “wb” and “rb+”<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    Text and binary are not modes that create files. They only change how the file is read or written, and “rt” and “rb” only read. Pay attention to two details in the table above. Write mode erases the old content, and create mode raises an error if the file already exists. Both are shown next.<\/p>\n
    Write Mode<\/h3>\n
    Write mode creates the file if it is not there. If it is there, it erases everything inside first. This is the most common way to lose data by accident.<\/p>\n
    \n
    python<\/div>\n
    f = open(\"test.txt\", \"w\")\r\nf.write(\"Writing in this file\\n\")\r\nf.write(\"Second line\\n\")\r\nf.write(\"Third line\\n\")\r\nf.close()<\/pre>\n<\/div>\n
    The write<\/code> method does not add a new line for you. We put \\n<\/code> at the end of each line, which means a line break. The method gives no output, but the file now holds three lines.<\/p>\n
    Read Mode<\/h3>\n
    Read mode opens an existing file for reading. It is the default, so open(\"test.txt\")<\/code> means the same as open(\"test.txt\", \"r\")<\/code>.<\/p>\n
    \n
    python<\/div>\n
    f = open(\"test.txt\", \"r\")\r\nprint(f.read())\r\nf.close()<\/pre>\n
    output<\/div>\n
    Writing in this file\r\nSecond line\r\nThird line<\/pre>\n<\/div>\n
    Append Mode<\/h3>\n
    Append mode keeps what is already in the file and adds the new text at the end.<\/p>\n
    \n
    python<\/div>\n
    f = open(\"test.txt\", \"a\")\r\nf.write(\"Adding this line to file\\n\")\r\nf.close()\r\nf = open(\"test.txt\", \"r\")\r\nprint(f.read())\r\nf.close()<\/pre>\n
    output<\/div>\n
    Writing in this file\r\nSecond line\r\nThird line\r\nAdding this line to file<\/pre>\n<\/div>\n
    Create Mode<\/h3>\n
    Create mode makes a new file, and refuses to touch one that already exists. It is the safe choice when you must not overwrite anything. The second part of the example creates a new file, which we delete later.<\/p>\n
    \n
    python<\/div>\n
    import os\r\n\r\ntry:\r\n    f = open(\"test.txt\", \"x\")\r\nexcept FileExistsError as e:\r\n    print(\"FileExistsError:\", e)\r\nf = open(\"brand_new.txt\", \"x\")\r\nf.close()\r\nprint(os.path.exists(\"brand_new.txt\"))<\/pre>\n
    output<\/div>\n
    FileExistsError: [Errno 17] File exists: 'test.txt'\r\nTrue<\/pre>\n<\/div>\n
    Read and Write Mode<\/h3>\n
    The mode r+<\/code> lets you read and write in the same file, and it does not erase the content. The writing starts wherever the pointer is. After a full read, the pointer is at the end, so the new text is added there. First we make a small file, which also shows that write mode erases the old content.<\/p>\n
    \n
    python<\/div>\n
    f = open(\"notes.txt\", \"w\")\r\nf.write(\"Fresh start\\n\")\r\nf.close()<\/pre>\n<\/div>\n
    \n
    python<\/div>\n
    f = open(\"notes.txt\", \"r+\")\r\nprint(repr(f.read()))\r\nf.write(\"Added after reading\\n\")\r\nf.seek(0)\r\nprint(repr(f.read()))\r\nf.close()<\/pre>\n
    output<\/div>\n
    'Fresh start\\n'\r\n'Fresh start\\nAdded after reading\\n'<\/pre>\n<\/div>\n
    The file held one line, Fresh start. The function repr<\/code> shows the line breaks as \\n<\/code> so you can see them.<\/p>\n
    Text Mode and Binary Mode<\/h3>\n
    Text mode is the default. Python turns the bytes in the file into text for you. Binary mode gives you the raw bytes, and you need it for images, audio, PDFs and any file that is not plain text. Add the letter b to the mode.<\/p>\n
    \n
    python<\/div>\n
    data = bytes([72, 101, 108, 108, 111])\r\nf = open(\"data.bin\", \"wb\")\r\nf.write(data)\r\nf.close()\r\nf = open(\"data.bin\", \"rb\")\r\nprint(f.read())\r\nf.close()\r\nf = open(\"data.bin\", \"rb+\")\r\nprint(f.read(2))\r\nf.close()<\/pre>\n
    output<\/div>\n
    b'Hello'\r\nb'He'<\/pre>\n<\/div>\n
    The mode rb+<\/code> reads and writes bytes. The b before the quotes in the output means the result is bytes and not text.<\/p>\n
    Use of read()<\/h3>\n
    Without a number, read<\/code> returns the whole file as one text. With a number, it returns that many characters. A common mistake is to call it twice on the same open file and expect the second call to give the first four characters. First, we write the three lines again, so the next examples are easy to follow.<\/p>\n
    \n
    python<\/div>\n
    with open(\"test.txt\", \"w\") as f:\r\n    f.write(\"Writing in this file\\nSecond line\\nThird line\\n\")<\/pre>\n<\/div>\n
    \n
    python<\/div>\n
    f = open(\"test.txt\", \"r\")\r\nprint(repr(f.read()))\r\nprint(repr(f.read(4)))\r\nf.close()<\/pre>\n
    output<\/div>\n
    'Writing in this file\\nSecond line\\nThird line\\n'\r\n''<\/pre>\n<\/div>\n
    The second call returns an empty text, because the first call already read to the end. A file keeps a position, called the pointer, and every read moves it forward. To get the first four characters, read them on a fresh file object, or move the pointer back to the start with seek<\/code>.<\/p>\n
    \n
    python<\/div>\n
    f = open(\"test.txt\", \"r\")\r\nprint(repr(f.read(4)))\r\nprint(f.tell())\r\nf.seek(0)\r\nprint(repr(f.read(7)))\r\nf.close()<\/pre>\n
    output<\/div>\n
    'Writ'\r\n4\r\n'Writing'<\/pre>\n<\/div>\n
    The method tell<\/code> gives the pointer position, and seek(0)<\/code> moves it back to the start.<\/p>\n
    Use of readline() and readlines()<\/h3>\n
    These are two different methods, and they are often mixed up.<\/p>\n
    \n\n\n\n\n\n\n\n
    read, readline and readlines<\/caption>\n
    Method<\/th>\nWhat it returns<\/th>\n<\/tr>\n<\/thead>\n
    read()<\/th>\nThe whole file as one text<\/td>\n<\/tr>\n
    readline()<\/th>\nOne line, including its line break. Each call gives the next line<\/td>\n<\/tr>\n
    readlines()<\/th>\nA list of all the lines<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    \n
    python<\/div>\n
    f = open(\"test.txt\", \"r\")\r\nprint(repr(f.readline()))\r\nprint(repr(f.readline()))\r\nf.close()\r\n \r\nf = open(\"test.txt\", \"r\")\r\nlines = f.readlines()\r\nprint(lines)\r\nprint(len(lines))\r\nf.close()<\/pre>\n
    output<\/div>\n
    'Writing in this file\\n'\r\n'Second line\\n'\r\n['Writing in this file\\n', 'Second line\\n', 'Third line\\n']\r\n3<\/pre>\n<\/div>\n
    Loop Over a File Line by Line<\/h3>\n
    For large files, do not read everything into memory. Loop over the file object, and Python gives you one line at a time.<\/p>\n
    \n
    python<\/div>\n
    f = open(\"test.txt\", \"r\")\r\nfor number, line in enumerate(f, start=1):\r\n    print(number, line.strip())\r\nf.close()<\/pre>\n
    output<\/div>\n
    1 Writing in this file\r\n2 Second line\r\n3 Third line<\/pre>\n<\/div>\n
    The strip<\/code> method removes the line break at the end of each line, so print<\/code> does not add a blank line.<\/p>\n
    Use of close()<\/h3>\n
    The close<\/code> method saves any waiting data and releases the file. If you forget to close a file you have written to, some of your data may never reach the disk. A closed file cannot be read again:<\/p>\n
    \n
    python<\/div>\n
    f = open(\"test.txt\")\r\nf.close()\r\ntry:\r\n    f.read()\r\nexcept ValueError as e:\r\n    print(\"ValueError:\", e)<\/pre>\n
    output<\/div>\n
    ValueError: I\/O operation on closed file.<\/pre>\n<\/div>\n
    The with Statement: The Better Way<\/h3>\n
    Writing close<\/code> by hand is easy to forget, and it is skipped when an error happens. The with<\/code> statement fixes this. It closes the file for you when the block ends, even if there is an error. Most Python programmers use this form all the time.<\/p>\n
    \n
    python<\/div>\n
    with open(\"notes.txt\") as f:\r\n    content = f.read()\r\nprint(f.closed)\r\nprint(content.splitlines())<\/pre>\n
    output<\/div>\n
    True\r\n['Fresh start', 'Added after reading']<\/pre>\n<\/div>\n
    The line print(f.closed)<\/code> shows True, so the file was closed automatically after the block.<\/p>\n
    Use of write() and writelines()<\/h3>\n
    The write<\/code> method takes one text. To write several lines at once, use writelines<\/code> with a list. It does not add line breaks either, so put them in the list.<\/p>\n
    \n
    python<\/div>\n
    with open(\"list.txt\", \"w\") as f:\r\n    f.writelines([\"apple\\n\", \"banana\\n\", \"cherry\\n\"])\r\nwith open(\"list.txt\") as f:\r\n    print([line.strip() for line in f])<\/pre>\n
    output<\/div>\n
    ['apple', 'banana', 'cherry']<\/pre>\n<\/div>\n
    Renaming a File<\/h2>\n
    Renaming uses the os<\/code> module. Here is the correct form, followed by what happens when the file is missing.<\/p>\n
    \n
    python<\/div>\n
    import os\r\n \r\nos.rename(\"test.txt\", \"python_file.txt\")\r\nprint(os.path.exists(\"test.txt\"), os.path.exists(\"python_file.txt\"))\r\ntry:\r\n    os.rename(\"test.txt\", \"other.txt\")\r\nexcept FileNotFoundError as e:\r\n    print(\"FileNotFoundError:\", e)<\/pre>\n
    output<\/div>\n
    False True\r\nFileNotFoundError: [Errno 2] No such file or directory: 'test.txt' -> 'other.txt'<\/pre>\n<\/div>\n
    The first rename works, so test.txt is gone and python_file.txt exists. The second rename fails, because test.txt is no longer there.<\/p>\n