How to read, write and create files in Python

The operation of files and folders (file operation functions) in python requires the os module and shutil module.

Get the current working directory, that is, the directory path where the current Python script works: os.getcwd()

Return all files and directory names in the specified directory: os.listdir()

The function is used to delete a file: os.remove()

Delete multiple directories: os.removedirs(r "c:\python")

The test is given Whether the path is a file: os.path.isfile()

Check whether the given path is a directory: os.path.isdir()

Judge whether it is an absolute path: os .path.isabs()

Check whether the given path actually exists: os.path.exists()

Return the directory name and file name of a path: os.path.split( ) eg os.path.split('/home/swaroop/byte/code/poem.txt') Result: ('/home/swaroop/byte/code', 'poem.txt')

Separation Extension: os.path.splitext()

Get the path name: os.path.dirname()

Get the file name: os.path.basename()

Run the shell command: os.system()

Read and set environment variables: os.getenv() and os.putenv()

give the line terminator used by the current platform: os .linesep Windows uses '\r\n', Linux uses '\n' and Mac uses '\r'

Indicate which platform you are using: os.name For Windows it is 'nt' while For Linux/Unix users it is 'posix'

Rename: os.rename(old, new)

Create multi-level directories: os.makedirs(r"c:\python\ test")

Create a single directory: os.mkdir("test")

Get file attributes: os.stat(file)

Modify file permissions and timestamps: os.chmod(file)

Terminate the current process: os.exit()

Get the file size: os.path.getsize(filename)

File operations ：
os.mknod("test.txt") creates an empty file
fp = open("test.txt",w) directly opens a file, and creates the file if it does not exist

About open mode:

w opens for writing,
a opens in append mode (starts from EOF, creates a new file if necessary)
r+ opens in read-write mode
w+ opens for reading Open in write mode (see w)
a+ Open in read-write mode (see a)
rb Open in binary read mode
wb Open in binary write mode (see w)
ab Open in binary append mode Open (see a)
rb+ Open in binary read-write mode (see r+)
wb+ Open in binary read-write mode (see w+)
ab+ Open in binary read-write mode (see a+)

fp.read([size]) #size is the length of the read, in bytes.

fp.readline([size]) #Read a line. If size is defined, it may be returned. Just a part of a line

fp.readlines([size]) # Treat each line of the file as a member of a list and return the list. In fact, it is implemented internally by calling readline() in a loop. If the size parameter is provided, size represents the total length of the read content, which means that only a part of the file may be read.

fp.write(str) #Write str to the file, write() will not add a newline character after str

fp.writelines(seq) #Write seq All contents are written to the file (multiple lines are written at once). This function also just writes faithfully, without adding anything after each line.

fp.close() #Close the file. Python will automatically close a file after it is no longer used. However, this function is not guaranteed. It is best to develop the habit of closing it yourself. If a file is operated on after it is closed, a ValueError will be generated

fp.flush() #Write the contents of the buffer to the hard disk

fp.fileno() #Return a long integer Type of "file label"

fp.isatty() #Whether the file is a terminal device file (in a unix system)

fp.tell() #Return the current position of the file operation mark , taking the beginning of the file as the origin

fp.next() #Return to the next line and move the file operation mark to the next line. When a file is used in a statement such as for...in file, the next() function is called to implement traversal.

fp.seek(offset[,whence]) #Move the file operation mark to the offset position. This offset is generally calculated relative to the beginning of the file, and is generally a positive number. But this is not necessarily the case if the whence parameter is provided. whence can be 0 to start calculation from the beginning, and 1 to calculate from the current position as the origin. 2 means the calculation is performed with the end of the file as the origin. It should be noted that if the file is opened in a or a+ mode, the file operation mark will automatically return to the end of the file every time a write operation is performed.

fp.truncate([size]) #Cut the file to the specified size. The default is to cut to the position of the current file operation mark. If size is larger than the file size, depending on the system, the file may not be changed, the file may be padded to the corresponding size with 0, or some random content may be added.

Directory operation:
os.mkdir("file") Create directory
Copy file:
shutil.copyfile("oldfile","newfile") Both oldfile and newfile can only be files
shutil.copy("oldfile","newfile") oldfile can only be a folder, newfile can be a file or a target directory
Copy folder:
shutil.copytree("olddir","newdir ") Both olddir and newdir can only be directories, and newdir must not exist
Rename files (directories)
os.rename("oldname","newname") Use this command for files or directories
Move files (directories)
shutil.move("oldpos","newpos")
Delete files
os.remove("file")
Delete directories
os.rmdir( "dir") can only delete empty directories
shutil.rmtree("dir") Both empty directories and directories with content can be deleted
Convert directory
os.chdir("path") Change path

Python reads and writes files

1.open
After using open to open a file, you must remember to call the close() method of the file object. For example, you can use the try/finally statement to ensure that the file can be closed finally.

file_object = open('thefile.txt')
try:
all_the_text = file_object.read( )
finally:
file_object.close( )

Note: The open statement cannot be placed in the try block because when an exception occurs when opening the file, the file object file_object cannot execute the close() method.

2. Read files
Read text files
input = open('data', 'r')
#The second parameter defaults to r
input = open(' data')

Read binary file
input = open('data', 'rb')

Read all contents
file_object = open('thefile. txt')
try:
all_the_text = file_object.read( )
finally:
file_object.close( )

Read fixed bytes
file_object = open ('abinfile', 'rb')
try:
while True:
chunk = file_object.read(100)
if not chunk:
break
do_something_with(chunk)
finally:
file_object.close( )

Read each line
list_of_all_the_lines = file_object.readlines( )

If the file is a text file, you can also traverse it directly File object gets each line:

for line in file_object:
process line

3. Write file
Write text file
output = open('data ', 'w')

Write binary file
output = open('data', 'wb')

Append write file
output = open('data', 'w+')

Write data
file_object = open('thefile.txt', 'w')
file_object.write(all_the_text)
file_object.close( )

Write multiple lines
file_object.writelines(list_of_text_strings)

Note that calling writelines to write multiple lines is more efficient than using write at once Write to high.

When processing log files, we often encounter such a situation: the log file is huge and it is impossible to read the entire file into the memory for processing at one time. For example, it needs to be on a computer with a physical memory of 2GB. Processing a 2GB log file on the machine, we may want to process only 200MB of its content at a time.
In Python, the built-in File object directly provides a readlines(sizehint) function to accomplish such a thing. Take the following code as an example:

file = open('test.log', 'r')sizehint = 209715200 # 200Mposition = 0lines = file.readlines(sizehint)while not file.tell() - position < 0: position = file.tell() lines = file.readlines(sizehint)

Every time the readlines(sizehint) function is called, approximately 200MB of data will be returned, and the data returned must be complete. Line data, in most cases, the number of bytes of the returned data will be slightly larger than the value specified by sizehint (except when the readlines(sizehint) function is called for the last time). Normally, Python will automatically adjust the user-specified sizehint value to an integer multiple of the internal cache size.

file is a special type in python, which is used to operate external files in python programs. Everything in Python is an object, and file is no exception. File has file methods and attributes. Let’s first look at how to create a file object:

file(name[, mode[, buffering]])
The file() function is used to create a file object. It has an alias called open(), which may be more vivid. They are built-in functions. . Let’s take a look at its parameters. Its parameters are all passed in the form of strings. name is the name of the file.
mode is the open mode. The optional values ​​are r w a U, which represent read (default) and write. Add modes that support various line breaks. If you open a file in w or a mode, if the file does not exist, it will be created automatically. In addition, when using w mode to open an existing file, the content of the original file will be cleared, because the initial file operation mark is at the beginning of the file. If you perform a write operation at this time, the original content will undoubtedly be deleted. Erase it. Due to historical reasons, the newline character has different modes in different systems. For example, in Unix it is a \n, but in Windows it is '\r\n'. Opening a file in U mode supports all newline modes. In other words, '\r' '\n' '\r\n' can represent a newline, and there will be a tuple used to store the newline characters used in this file. However, although there are many modes for line breaks, when reading python, they are always replaced by \n. After the mode character, you can also add the two signs + b t, which respectively indicate that the file can be read and written at the same time and the file can be opened in binary mode or text mode (default).
buffering If it is 0, it means no buffering; if it is 1, it means "line buffering"; if it is a number greater than 1, it means the size of the buffer, which should be in bytes.

The file object has its own properties and methods. Let’s first look at the attributes of file.

closed #Mark whether the file has been closed, rewritten by close()
encoding #File encoding
mode #Open mode
name #File name
newlines #In the file The newline mode used is a tuple
softspace #boolean type, usually 0. It is said to be used for reading and writing print

file:

F.read([size] ) #size is the length of the read, in bytes.
F.readline([size])
#Read a line. If size is defined, it is possible to return only a part of the line.
F.readlines ([size])
# Treat each line of the file as a member of a list and return the list. In fact, it is implemented internally by calling readline() in a loop. If the size parameter is provided, size represents the total length of the read content, which means that only a part of the file may be read.
F.write(str)
#Write str to the file, write() will not add a newline character after str
F.writelines(seq)
#Put seq All contents are written to the file. This function also just writes faithfully, without adding anything after each line.

Other methods of file:

F.close()
#Close the file. Python will automatically close a file after it is no longer used. However, this function is not guaranteed. It is best to develop the habit of closing it yourself. If a file is operated on after it is closed, a ValueError will be generated
F.flush()
#Write the contents of the buffer to the hard disk
F.fileno()
#Return a long integer Type of "file label"
F.isatty()
#Whether the file is a terminal device file (in a unix system)
F.tell()
#Returns the current position of the file operation mark , taking the beginning of the file as the origin
F.next()
#Return to the next line and move the file operation flag to the next line. When a file is used in a statement such as for ... in file, the next() function is called to implement traversal.
F.seek(offset[,whence])
#Move the file operation mark to the offset position. This offset is generally calculated relative to the beginning of the file, and is generally a positive number. But this is not necessarily the case if the whence parameter is provided. whence can be 0 to start the calculation from the beginning, and 1 to use the current position as the origin. 2 means the calculation is performed with the end of the file as the origin. It should be noted that if the file is opened in a or a+ mode, the file operation mark will automatically return to the end of the file every time a write operation is performed.
F.truncate([size])
#Cut the file to the specified size. The default is to cut to the position of the current file operation mark. If size is larger than the file size, depending on the system, the file may not be changed, the file may be padded to the corresponding size with 0, or some random content may be added.

The above method of reading, writing, and creating files in Python (a must-read) is all the content shared by the editor. I hope it can give you a reference, and I also hope that everyone will support the PHP Chinese website.

For more articles related to Python methods of reading, writing, and creating files, please pay attention to the PHP Chinese website!