Open File in Read Write Mode Python
Watch At present This tutorial has a related video form created by the Existent Python team. Spotter it together with the written tutorial to deepen your understanding: Reading and Writing Files in Python
One of the almost common tasks that you can do with Python is reading and writing files. Whether it's writing to a simple text file, reading a complicated server log, or even analyzing raw byte data, all of these situations crave reading or writing a file.
In this tutorial, you lot'll learn:
- What makes up a file and why that's of import in Python
- The basics of reading and writing files in Python
- Some basic scenarios of reading and writing files
This tutorial is mainly for beginner to intermediate Pythonistas, just there are some tips in here that more advanced programmers may appreciate as well.
What Is a File?
Before we tin become into how to work with files in Python, information technology'south important to sympathize what exactly a file is and how modern operating systems handle some of their aspects.
At its core, a file is a face-to-face ready of bytes used to store information. This data is organized in a specific format and can be anything every bit unproblematic every bit a text file or as complicated as a plan executable. In the stop, these byte files are and so translated into binary 1 and 0 for easier processing by the estimator.
Files on near modern file systems are composed of three master parts:
- Header: metadata about the contents of the file (file name, size, type, so on)
- Information: contents of the file every bit written by the creator or editor
- Finish of file (EOF): special character that indicates the stop of the file
What this data represents depends on the format specification used, which is typically represented by an extension. For case, a file that has an extension of .gif nearly likely conforms to the Graphics Interchange Format specification. There are hundreds, if not thousands, of file extensions out there. For this tutorial, y'all'll only deal with .txt or .csv file extensions.
File Paths
When you access a file on an operating system, a file path is required. The file path is a string that represents the location of a file. It'south cleaved up into iii major parts:
- Folder Path: the file folder location on the file organization where subsequent folders are separated by a frontwards slash
/(Unix) or backslash\(Windows) - File Name: the actual name of the file
- Extension: the end of the file path pre-pended with a period (
.) used to indicate the file type
Here'southward a quick example. Let'south say you have a file located within a file construction like this:
/ │ ├── path/ | │ │ ├── to/ │ │ └── cats.gif │ │ │ └── dog_breeds.txt | └── animals.csv Let's say you wanted to access the cats.gif file, and your current location was in the same binder as path. In order to admission the file, y'all need to go through the path binder and then the to folder, finally arriving at the cats.gif file. The Binder Path is path/to/. The File Name is cats. The File Extension is .gif. And so the full path is path/to/cats.gif.
Now let's say that your current location or current working directory (cwd) is in the to folder of our example folder structure. Instead of referring to the cats.gif past the total path of path/to/cats.gif, the file tin can be but referenced by the file name and extension cats.gif.
/ │ ├── path/ | │ | ├── to/ ← Your electric current working directory (cwd) is hither | │ └── cats.gif ← Accessing this file | │ | └── dog_breeds.txt | └── animals.csv But what well-nigh dog_breeds.txt? How would you access that without using the full path? You can use the special characters double-dot (..) to movement one directory up. This ways that ../dog_breeds.txt will reference the dog_breeds.txt file from the directory of to:
/ │ ├── path/ ← Referencing this parent folder | │ | ├── to/ ← Current working directory (cwd) | │ └── cats.gif | │ | └── dog_breeds.txt ← Accessing this file | └── animals.csv The double-dot (..) can be chained together to traverse multiple directories higher up the electric current directory. For example, to admission animals.csv from the to folder, you would use ../../animals.csv.
Line Endings
One trouble ofttimes encountered when working with file data is the representation of a new line or line ending. The line ending has its roots from back in the Morse Lawmaking era, when a specific pro-sign was used to communicate the finish of a transmission or the end of a line.
Later, this was standardized for teleprinters past both the International Organization for Standardization (ISO) and the American Standards Association (ASA). ASA standard states that line endings should use the sequence of the Carriage Return (CR or \r) and the Line Feed (LF or \n) characters (CR+LF or \r\n). The ISO standard however allowed for either the CR+LF characters or merely the LF character.
Windows uses the CR+LF characters to indicate a new line, while Unix and the newer Mac versions employ just the LF character. This can cause some complications when you're processing files on an operating arrangement that is different than the file's source. Hither's a quick example. Let'southward say that we examine the file dog_breeds.txt that was created on a Windows arrangement:
Pug\r\n Jack Russell Terrier\r\n English Springer Spaniel\r\north German Shepherd\r\n Staffordshire Bull Terrier\r\n Cavalier King Charles Spaniel\r\due north Golden Retriever\r\north West Highland White Terrier\r\n Boxer\r\northward Border Terrier\r\n This same output will exist interpreted on a Unix device differently:
Pug\r \n Jack Russell Terrier\r \n English Springer Spaniel\r \n German language Shepherd\r \n Staffordshire Bull Terrier\r \due north Cavalier King Charles Spaniel\r \n Gilded Retriever\r \n Westward Highland White Terrier\r \n Boxer\r \due north Border Terrier\r \n This can make iterating over each line problematic, and you lot may need to account for situations like this.
Character Encodings
Another common problem that you may face is the encoding of the byte information. An encoding is a translation from byte data to man readable characters. This is typically washed by assigning a numerical value to represent a grapheme. The two most common encodings are the ASCII and UNICODE Formats. ASCII can simply store 128 characters, while Unicode can contain upwardly to ane,114,112 characters.
ASCII is actually a subset of Unicode (UTF-viii), meaning that ASCII and Unicode share the same numerical to character values. It's important to note that parsing a file with the incorrect character encoding can lead to failures or misrepresentation of the character. For example, if a file was created using the UTF-8 encoding, and you try to parse it using the ASCII encoding, if in that location is a character that is exterior of those 128 values, then an mistake will be thrown.
Opening and Closing a File in Python
When you want to work with a file, the first matter to practise is to open up it. This is washed by invoking the open up() congenital-in function. open up() has a single required argument that is the path to the file. open() has a single return, the file object:
file = open ( 'dog_breeds.txt' ) After you open a file, the side by side thing to learn is how to close it.
It's important to call up that it's your responsibility to shut the file. In most cases, upon termination of an application or script, a file will be closed somewhen. However, at that place is no guarantee when exactly that will happen. This tin lead to unwanted behavior including resource leaks. It's also a best practice inside Python (Pythonic) to brand sure that your code behaves in a way that is well defined and reduces whatsoever unwanted beliefs.
When you're manipulating a file, at that place are two ways that you can use to ensure that a file is closed properly, even when encountering an error. The commencement way to shut a file is to utilise the attempt-finally block:
reader = open up ( 'dog_breeds.txt' ) attempt : # Further file processing goes here finally : reader . close () If you're unfamiliar with what the endeavour-finally block is, check out Python Exceptions: An Introduction.
The second way to close a file is to use the with statement:
with open ( 'dog_breeds.txt' ) as reader : # Further file processing goes hither The with statement automatically takes care of closing the file once it leaves the with block, even in cases of mistake. I highly recommend that y'all utilise the with statement as much every bit possible, as it allows for cleaner code and makes treatment any unexpected errors easier for you lot.
Well-nigh likely, y'all'll also want to use the second positional argument, fashion. This argument is a string that contains multiple characters to represent how you want to open the file. The default and well-nigh common is 'r', which represents opening the file in read-only manner equally a text file:
with open ( 'dog_breeds.txt' , 'r' ) as reader : # Further file processing goes hither Other options for modes are fully documented online, but the almost normally used ones are the post-obit:
| Graphic symbol | Meaning |
|---|---|
'r' | Open up for reading (default) |
'westward' | Open up for writing, truncating (overwriting) the file first |
'rb' or 'wb' | Open up in binary mode (read/write using byte data) |
Let's become back and talk a little about file objects. A file object is:
"an object exposing a file-oriented API (with methods such equally
read()orwrite()) to an underlying resources." (Source)
There are three different categories of file objects:
- Text files
- Buffered binary files
- Raw binary files
Each of these file types are divers in the io module. Here'due south a quick rundown of how everything lines upward.
Text File Types
A text file is the most common file that you'll encounter. Here are some examples of how these files are opened:
open ( 'abc.txt' ) open ( 'abc.txt' , 'r' ) open up ( 'abc.txt' , 'w' ) With these types of files, open() will return a TextIOWrapper file object:
>>>
>>> file = open up ( 'dog_breeds.txt' ) >>> type ( file ) <class '_io.TextIOWrapper'> This is the default file object returned by open().
Buffered Binary File Types
A buffered binary file type is used for reading and writing binary files. Hither are some examples of how these files are opened:
open ( 'abc.txt' , 'rb' ) open ( 'abc.txt' , 'wb' ) With these types of files, open() will return either a BufferedReader or BufferedWriter file object:
>>>
>>> file = open ( 'dog_breeds.txt' , 'rb' ) >>> blazon ( file ) <form '_io.BufferedReader'> >>> file = open ( 'dog_breeds.txt' , 'wb' ) >>> type ( file ) <class '_io.BufferedWriter'> Raw File Types
A raw file blazon is:
"more often than not used as a low-level edifice-block for binary and text streams." (Source)
It is therefore not typically used.
Here'southward an case of how these files are opened:
open ( 'abc.txt' , 'rb' , buffering = 0 ) With these types of files, open() will render a FileIO file object:
>>>
>>> file = open ( 'dog_breeds.txt' , 'rb' , buffering = 0 ) >>> blazon ( file ) <class '_io.FileIO'> Reading and Writing Opened Files
Once you've opened up a file, you'll want to read or write to the file. First off, allow's encompass reading a file. There are multiple methods that can be called on a file object to help y'all out:
| Method | What It Does |
|---|---|
.read(size=-i) | This reads from the file based on the number of size bytes. If no argument is passed or None or -1 is passed, so the entire file is read. |
.readline(size=-1) | This reads at most size number of characters from the line. This continues to the stop of the line and then wraps dorsum around. If no argument is passed or None or -1 is passed, then the entire line (or residual of the line) is read. |
.readlines() | This reads the remaining lines from the file object and returns them as a list. |
Using the aforementioned dog_breeds.txt file you used higher up, let's get through some examples of how to use these methods. Hither'southward an example of how to open and read the unabridged file using .read():
>>>
>>> with open ( 'dog_breeds.txt' , 'r' ) as reader : >>> # Read & print the entire file >>> print ( reader . read ()) Pug Jack Russell Terrier English Springer Spaniel German Shepherd Staffordshire Bull Terrier Cavalier King Charles Spaniel Golden Retriever West Highland White Terrier Boxer Border Terrier Here'south an example of how to read 5 bytes of a line each time using the Python .readline() method:
>>>
>>> with open ( 'dog_breeds.txt' , 'r' ) as reader : >>> # Read & print the first 5 characters of the line 5 times >>> print ( reader . readline ( 5 )) >>> # Notice that line is greater than the v chars and continues >>> # down the line, reading 5 chars each time until the stop of the >>> # line and so "wraps" effectually >>> print ( reader . readline ( 5 )) >>> print ( reader . readline ( 5 )) >>> print ( reader . readline ( 5 )) >>> print ( reader . readline ( 5 )) Pug Jack Russe ll Te rrier Hither'due south an instance of how to read the entire file as a list using the Python .readlines() method:
>>>
>>> f = open ( 'dog_breeds.txt' ) >>> f . readlines () # Returns a listing object ['Pug\n', 'Jack Russell Terrier\n', 'English language Springer Spaniel\n', 'German Shepherd\northward', 'Staffordshire Balderdash Terrier\northward', 'Cavalier King Charles Spaniel\north', 'Golden Retriever\n', 'West Highland White Terrier\north', 'Boxer\n', 'Border Terrier\n'] The to a higher place case can also be done by using list() to create a listing out of the file object:
>>>
>>> f = open ( 'dog_breeds.txt' ) >>> list ( f ) ['Pug\due north', 'Jack Russell Terrier\north', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'W Highland White Terrier\n', 'Boxer\due north', 'Border Terrier\due north'] Iterating Over Each Line in the File
A common thing to practise while reading a file is to iterate over each line. Here's an example of how to utilize the Python .readline() method to perform that iteration:
>>>
>>> with open ( 'dog_breeds.txt' , 'r' ) equally reader : >>> # Read and print the entire file line by line >>> line = reader . readline () >>> while line != '' : # The EOF char is an empty cord >>> print ( line , end = '' ) >>> line = reader . readline () Pug Jack Russell Terrier English Springer Spaniel German language Shepherd Staffordshire Bull Terrier Cavalier King Charles Spaniel Golden Retriever Due west Highland White Terrier Boxer Edge Terrier Some other way you could iterate over each line in the file is to apply the Python .readlines() method of the file object. Recollect, .readlines() returns a listing where each element in the list represents a line in the file:
>>>
>>> with open ( 'dog_breeds.txt' , 'r' ) as reader : >>> for line in reader . readlines (): >>> print ( line , cease = '' ) Pug Jack Russell Terrier English language Springer Spaniel German Shepherd Staffordshire Bull Terrier Cavalier King Charles Spaniel Gold Retriever Westward Highland White Terrier Boxer Border Terrier Even so, the above examples tin exist further simplified past iterating over the file object itself:
>>>
>>> with open ( 'dog_breeds.txt' , 'r' ) every bit reader : >>> # Read and impress the entire file line past line >>> for line in reader : >>> impress ( line , finish = '' ) Pug Jack Russell Terrier English Springer Spaniel High german Shepherd Staffordshire Bull Terrier Condescending King Charles Spaniel Golden Retriever West Highland White Terrier Boxer Border Terrier This terminal approach is more Pythonic and can be quicker and more memory efficient. Therefore, it is suggested you use this instead.
Now let'southward dive into writing files. Every bit with reading files, file objects have multiple methods that are useful for writing to a file:
| Method | What It Does |
|---|---|
.write(cord) | This writes the string to the file. |
.writelines(seq) | This writes the sequence to the file. No line endings are appended to each sequence item. It's up to yous to add the appropriate line ending(s). |
Here's a quick example of using .write() and .writelines():
with open ( 'dog_breeds.txt' , 'r' ) equally reader : # Note: readlines doesn't trim the line endings dog_breeds = reader . readlines () with open ( 'dog_breeds_reversed.txt' , 'w' ) equally author : # Alternatively yous could use # author.writelines(reversed(dog_breeds)) # Write the domestic dog breeds to the file in reversed lodge for breed in reversed ( dog_breeds ): writer . write ( breed ) Working With Bytes
Sometimes, you may need to work with files using byte strings. This is done by adding the 'b' graphic symbol to the manner statement. All of the aforementioned methods for the file object apply. Withal, each of the methods expect and return a bytes object instead:
>>>
>>> with open ( 'dog_breeds.txt' , 'rb' ) every bit reader : >>> print ( reader . readline ()) b'Pug\north' Opening a text file using the b flag isn't that interesting. Let's say we accept this cute picture show of a Jack Russell Terrier (jack_russell.png):
You lot tin can actually open up that file in Python and examine the contents! Since the .png file format is well defined, the header of the file is 8 bytes cleaved up similar this:
| Value | Interpretation |
|---|---|
0x89 | A "magic" number to indicate that this is the first of a PNG |
0x50 0x4E 0x47 | PNG in ASCII |
0x0D 0x0A | A DOS style line ending \r\n |
0x1A | A DOS style EOF grapheme |
0x0A | A Unix style line catastrophe \due north |
Sure enough, when you open the file and read these bytes individually, you lot can see that this is indeed a .png header file:
>>>
>>> with open ( 'jack_russell.png' , 'rb' ) as byte_reader : >>> impress ( byte_reader . read ( i )) >>> print ( byte_reader . read ( 3 )) >>> impress ( byte_reader . read ( 2 )) >>> print ( byte_reader . read ( one )) >>> print ( byte_reader . read ( 1 )) b'\x89' b'PNG' b'\r\n' b'\x1a' b'\north' A Full Example: dos2unix.py
Allow's bring this whole thing dwelling and look at a full example of how to read and write to a file. The following is a dos2unix like tool that will convert a file that contains line endings of \r\northward to \n.
This tool is broken upwards into three major sections. The first is str2unix(), which converts a string from \r\n line endings to \n. The second is dos2unix(), which converts a string that contains \r\n characters into \due north. dos2unix() calls str2unix() internally. Finally, there's the __main__ block, which is called only when the file is executed equally a script. Think of it equally the master function institute in other programming languages.
""" A unproblematic script and library to convert files or strings from dos like line endings with Unix like line endings. """ import argparse import os def str2unix ( input_str : str ) -> str : r """ Converts the string from \r\n line endings to \n Parameters ---------- input_str The string whose line endings will be converted Returns ------- The converted cord """ r_str = input_str . replace ( ' \r\n ' , ' \north ' ) return r_str def dos2unix ( source_file : str , dest_file : str ): """ Converts a file that contains Dos like line endings into Unix like Parameters ---------- source_file The path to the source file to exist converted dest_file The path to the converted file for output """ # Note: Could add file existence checking and file overwriting # protection with open ( source_file , 'r' ) as reader : dos_content = reader . read () unix_content = str2unix ( dos_content ) with open ( dest_file , 'due west' ) as writer : writer . write ( unix_content ) if __name__ == "__main__" : # Create our Statement parser and set its description parser = argparse . ArgumentParser ( clarification = "Script that converts a DOS like file to an Unix like file" , ) # Add the arguments: # - source_file: the source file we want to convert # - dest_file: the destination where the output should go # Note: the use of the statement blazon of argparse.FileType could # streamline some things parser . add_argument ( 'source_file' , aid = 'The location of the source ' ) parser . add_argument ( '--dest_file' , assist = 'Location of dest file (default: source_file appended with `_unix`' , default = None ) # Parse the args (argparse automatically grabs the values from # sys.argv) args = parser . parse_args () s_file = args . source_file d_file = args . dest_file # If the destination file wasn't passed, so assume we want to # create a new file based on the quondam one if d_file is None : file_path , file_extension = os . path . splitext ( s_file ) d_file = f ' { file_path } _unix { file_extension } ' dos2unix ( s_file , d_file ) Tips and Tricks
At present that you lot've mastered the nuts of reading and writing files, hither are some tips and tricks to help you grow your skills.
__file__
The __file__ attribute is a special attribute of modules, like to __name__. Information technology is:
"the pathname of the file from which the module was loaded, if information technology was loaded from a file." (Source
Here'southward a real globe instance. In one of my past jobs, I did multiple tests for a hardware device. Each exam was written using a Python script with the test script file name used as a championship. These scripts would and so be executed and could print their condition using the __file__ special attribute. Here's an case folder structure:
projection/ | ├── tests/ | ├── test_commanding.py | ├── test_power.py | ├── test_wireHousing.py | └── test_leds.py | └── master.py Running main.py produces the following:
>>> python main.py tests/test_commanding.py Started: tests/test_commanding.py Passed! tests/test_power.py Started: tests/test_power.py Passed! tests/test_wireHousing.py Started: tests/test_wireHousing.py Failed! tests/test_leds.py Started: tests/test_leds.py Passed! I was able to run and get the condition of all my tests dynamically through employ of the __file__ special attribute.
Appending to a File
Sometimes, y'all may desire to append to a file or start writing at the end of an already populated file. This is easily done by using the 'a' grapheme for the mode argument:
with open up ( 'dog_breeds.txt' , 'a' ) as a_writer : a_writer . write ( ' \n Beagle' ) When you examine dog_breeds.txt again, y'all'll see that the beginning of the file is unchanged and Beagle is at present added to the end of the file:
>>>
>>> with open ( 'dog_breeds.txt' , 'r' ) as reader : >>> print ( reader . read ()) Pug Jack Russell Terrier English language Springer Spaniel German Shepherd Staffordshire Bull Terrier Condescending King Charles Spaniel Golden Retriever West Highland White Terrier Boxer Border Terrier Beagle Working With 2 Files at the Same Time
There are times when you lot may desire to read a file and write to another file at the same time. If y'all use the example that was shown when you were learning how to write to a file, it can really exist combined into the following:
d_path = 'dog_breeds.txt' d_r_path = 'dog_breeds_reversed.txt' with open ( d_path , 'r' ) equally reader , open up ( d_r_path , 'w' ) as author : dog_breeds = reader . readlines () writer . writelines ( reversed ( dog_breeds )) Creating Your Own Context Managing director
There may come a time when you'll demand finer control of the file object by placing it inside a custom grade. When you lot do this, using the with statement tin no longer be used unless yous add a few magic methods: __enter__ and __exit__. By adding these, you'll have created what's called a context director.
__enter__() is invoked when calling the with argument. __exit__() is called upon exiting from the with argument block.
Hither's a template that you lot can utilise to make your custom form:
class my_file_reader (): def __init__ ( self , file_path ): cocky . __path = file_path self . __file_object = None def __enter__ ( self ): self . __file_object = open up ( self . __path ) return self def __exit__ ( cocky , blazon , val , tb ): self . __file_object . close () # Boosted methods implemented below Now that you've got your custom class that is now a context manager, you can use information technology similarly to the open() congenital-in:
with my_file_reader ( 'dog_breeds.txt' ) every bit reader : # Perform custom class operations pass Here'south a good example. Remember the cute Jack Russell image we had? Perhaps yous want to open other .png files but don't want to parse the header file each time. Here'southward an case of how to do this. This example also uses custom iterators. If you're not familiar with them, check out Python Iterators:
class PngReader (): # Every .png file contains this in the header. Employ it to verify # the file is indeed a .png. _expected_magic = b ' \x89 PNG \r\northward\x1a\north ' def __init__ ( self , file_path ): # Ensure the file has the right extension if not file_path . endswith ( '.png' ): raise NameError ( "File must exist a '.png' extension" ) self . __path = file_path self . __file_object = None def __enter__ ( self ): cocky . __file_object = open ( self . __path , 'rb' ) magic = self . __file_object . read ( eight ) if magic != self . _expected_magic : enhance TypeError ( "The File is not a properly formatted .png file!" ) render self def __exit__ ( self , type , val , tb ): self . __file_object . shut () def __iter__ ( self ): # This and __next__() are used to create a custom iterator # See https://dbader.org/blog/python-iterators render self def __next__ ( self ): # Read the file in "Chunks" # See https://en.wikipedia.org/wiki/Portable_Network_Graphics#%22Chunks%22_within_the_file initial_data = cocky . __file_object . read ( four ) # The file hasn't been opened or reached EOF. This means we # tin't go any further so stop the iteration past raising the # StopIteration. if self . __file_object is None or initial_data == b '' : raise StopIteration else : # Each chunk has a len, blazon, information (based on len) and crc # Catch these values and return them as a tuple chunk_len = int . from_bytes ( initial_data , byteorder = 'big' ) chunk_type = self . __file_object . read ( four ) chunk_data = cocky . __file_object . read ( chunk_len ) chunk_crc = self . __file_object . read ( 4 ) return chunk_len , chunk_type , chunk_data , chunk_crc You can now open .png files and properly parse them using your custom context manager:
>>>
>>> with PngReader ( 'jack_russell.png' ) every bit reader : >>> for 50 , t , d , c in reader : >>> print ( f " { l : 05 } , { t } , { c } " ) 00013, b'IHDR', b'v\x121k' 00001, b'sRGB', b'\xae\xce\x1c\xe9' 00009, b'pHYs', b'(<]\x19' 00345, b'iTXt', b"L\xc2'Y" 16384, b'IDAT', b'i\x99\x0c(' 16384, b'IDAT', b'\xb3\xfa\x9a$' 16384, b'IDAT', b'\xff\xbf\xd1\n' 16384, b'IDAT', b'\xc3\x9c\xb1}' 16384, b'IDAT', b'\xe3\x02\xba\x91' 16384, b'IDAT', b'\xa0\xa99=' 16384, b'IDAT', b'\xf4\x8b.\x92' 16384, b'IDAT', b'\x17i\xfc\xde' 16384, b'IDAT', b'\x8fb\x0e\xe4' 16384, b'IDAT', b')3={' 01040, b'IDAT', b'\xd6\xb8\xc1\x9f' 00000, b'IEND', b'\xaeB`\x82' Don't Re-Invent the Snake
There are common situations that yous may encounter while working with files. Most of these cases can be handled using other modules. Two common file types you may need to piece of work with are .csv and .json. Real Python has already put together some nifty articles on how to handle these:
- Reading and Writing CSV Files in Python
- Working With JSON Information in Python
Additionally, there are born libraries out there that you can use to aid you lot:
-
moving ridge: read and write WAV files (audio) -
aifc: read and write AIFF and AIFC files (audio) -
sunau: read and write Sun AU files -
tarfile: read and write tar archive files -
zipfile: work with Cypher athenaeum -
configparser: easily create and parse configuration files -
xml.etree.ElementTree: create or read XML based files -
msilib: read and write Microsoft Installer files -
plistlib: generate and parse Mac Bone X.plistfiles
There are plenty more than out in that location. Additionally there are even more than 3rd party tools available on PyPI. Some pop ones are the post-obit:
-
PyPDF2: PDF toolkit -
xlwings: read and write Excel files -
Pillow: image reading and manipulation
You're a File Wizard Harry!
You did information technology! You now know how to work with files with Python, including some advanced techniques. Working with files in Python should now exist easier than e'er and is a rewarding feeling when yous get-go doing information technology.
In this tutorial you've learned:
- What a file is
- How to open and shut files properly
- How to read and write files
- Some avant-garde techniques when working with files
- Some libraries to piece of work with mutual file types
If you lot have any questions, hit usa up in the comments.
Lookout man Now This tutorial has a related video course created by the Real Python squad. Sentry information technology together with the written tutorial to deepen your agreement: Reading and Writing Files in Python
lavalleythersellse.blogspot.com
Source: https://realpython.com/read-write-files-python/
Post a Comment for "Open File in Read Write Mode Python"