您一定在專案中多次使用過Python中os模組提供的函數。這些可用於建立檔案、遍歷目錄、取得目前目錄的資訊、執行路徑操作等等。
在本文中，我們將討論與 os 模組中的任何函數一樣有用但很少使用的函數。
當處理共用公用目錄結構的多個檔案時，您可能會想要找到最長的共用路徑。 os.path.commonpath() 就是這樣做的。這在組織文件或處理跨環境的不同路徑時非常有用。
這是一個例子：
import os
paths = ['/user/data/project1/file1.txt', '/user/data/project2/file2.txt']
common_path = os.path.commonpath(paths)
print("Common Path:", common_path)
此程式碼將為我們提供這兩個路徑共享的公共路徑。
Common Path: /user/data
您可以看到 os.path.commonpath() 取得路徑名列表，手動寫下它們可能不切實際。
在這種情況下，最好迭代所有目錄、子目錄和檔案名，然後尋找公共路徑。
import os
def get_file_paths(directory, file_extension=None):
# Collect all file paths in the directory (and subdirectories, if any)
file_paths = []
for root, dirs, files in os.walk(directory):
for file in files:
if file_extension is None or file.endswith(file_extension):
file_paths.append(os.path.join(root, file))
return file_paths
# Specify the root directory to start from
directory_path = 'D:/SACHIN/Pycharm/Flask-Tutorial'
# If you want to filter by file extension
file_paths = get_file_paths(directory_path, file_extension='.html')
# Find the common path among all files
if file_paths:
common_path = os.path.commonpath(file_paths)
print("Common Path:", common_path)
else:
print("No files found in the specified directory.")
在此範例中，函數 get_file_paths() 從上到下遍歷目錄並附加在 file_paths 清單中找到的所有路徑。如果我們想尋找特定文件，此函數可以選擇使用文件副檔名。
現在我們可以輕鬆找到任意目錄的公共路徑了。
Common Path: D:\SACHIN\Pycharm\Flask-Tutorial\templates
如果您使用 os.listdir() 來取得目錄的內容，請考慮使用 os.scandir() 來取代。它不僅速度更快，而且還返回 DirEntry 對象，該對象提供有用的信息，例如文件類型、權限以及條目是文件還是目錄。
這是一個例子：
import os
with os.scandir('D:/SACHIN/Pycharm/osfunctions') as entries:
for entry in entries:
print(f"{entry.name} : \n"
f">>>> Is File: {entry.is_file()} \n"
f">>>> Is Directory: {entry.is_dir()}")
在此範例中，我們使用 os.scandir() 並傳遞一個目錄，然後迭代該目錄並列印資訊。
.idea : >>>> Is File: False >>>> Is Directory: True main.py : >>>> Is File: True >>>> Is Directory: False sample.py : >>>> Is File: True >>>> Is Directory: False
假設您正在處理檔案並需要檢查其副檔名，您可以從 os.path.splitext() 函數獲得協助。它將檔案路徑分為根目錄和副檔名，可以幫助您確定檔案類型。
import os
filename = 'report.csv'
root, ext = os.path.splitext(filename)
print(f"Root: {root} \n"
f"Extension: {ext}")
輸出
Root: report Extension: .csv
看看一些路徑可能很奇怪的情況，當時 os.path.splitext() 是如何運作的。
import os
filename = ['.report', 'report', 'report.case.txt', 'report.csv.zip']
for idx, paths in enumerate(filename):
root, ext = os.path.splitext(paths)
print(f"{idx} - {paths}\n"
f"Root: {root} | Extension: {ext}")
輸出
0 - .report Root: .report | Extension: 1 - report Root: report | Extension: 2 - report.case.txt Root: report.case | Extension: .txt 3 - report.csv.zip Root: report.csv | Extension: .zip
已經有一個常用的功能可以讓我們建立目錄。但是當您建立巢狀目錄時該怎麼辦？
Creating nested directories can be a hassle with os.mkdir() since it only makes one directory at a time. os.makedirs() allows you to create multiple nested directories in one go, and the exist_ok=True argument makes sure it doesn’t throw an error if the directory already exists.
import os
os.makedirs('project/data/files', exist_ok=True)
print("Nested directories created!")
When we run this program, it will create specified directories and sub-directories.
Nested directories created!
If we run the above program again, it won’t throw an error due to exist_ok=True.
Similar to os.rename(), os.replace() moves a file to a new location, but it safely overwrites any existing file at the destination. This is helpful for tasks where you’re updating or backing up files and want to ensure that old files are safely replaced.
import os
os.replace(src='main.py', dst='new_main.py')
print("File replaced successfully!")
In this code, main.py file will be renamed to new_main.py just as os.rename() function but this operation is like take it all or nothing. It means the file replacement happens in a single, indivisible step, so either the entire operation succeeds or nothing changes at all.
File replaced successfully!
For cryptographic purposes, you need a secure source of random data. os.urandom() generates random bytes suitable for things like generating random IDs, tokens, or passwords. It’s more secure than the random module for sensitive data.
os.urandom() uses randomness generated by the operating system you are using from various resources to make bytes (data) unpredictable.
In Windows, it uses BCryptGenRandom() to generate random bytes.
import os
secure_token = os.urandom(16) # 16 bytes of random data
print("Secure Token:", secure_token)
#Making it human-readable
print("Secure Token:", secure_token.hex())
Output
Secure Token: b'\x84\xd6\x1c\x1bKB\x7f\xcd\xf6\xb7\xc4D\x92z\xe3{'
Secure Token: 84d61c1b4b427fcdf6b7c444927ae37b
The os.path.samefile() function in Python is used to check if two paths refer to the same file or directory on the filesystem. It’s particularly helpful in scenarios where multiple paths might point to the same physical file, such as when dealing with symbolic links, hard links, or different absolute and relative paths to the same location.
import os
is_same = os.path.samefile('/path/to/file1.txt', '/different/path/to/symlink_file1.txt')
print("Are they the same file?", is_same)
os.path.samefile() is designed to return True only if both paths reference the same file on disk, such as a file that’s hard-linked or symlinked to the same data on the filesystem.
os.path.relpath() is a computation function that computes the relative path between two paths. This is particularly useful when building file paths dynamically or working with relative imports.
Consider the following example:
import os # Target file path target_path = "D:/SACHIN/Pycharm/osfunctions/project/engine/log.py" # Starting point start_path = "D:/SACHIN/Pycharm/osfunctions/project/interface/character/specific.py" relative_path = os.path.relpath(target_path, start=start_path) print(relative_path)
In this example, we have target_path which contains a path where we have to navigate and start_path contains a path from where we have to start calculating the relative path to target_path.
When we run this, we get the following output.
..\..\..\engine\log.py
This means we have to go up three directories and then down to engine/log.py.
When we perform a file writing (file.write()) operation, the data isn’t saved to disk instantly instead the data is saved into the system’s buffer and if something unexpected happens before writing the data to the disk, the data gets lost.
os.fsync() forces the data to be written, ensuring data integrity. It’s especially useful in logging or when writing critical data that must not be lost.
import os
with open('data.txt', 'w') as f:
f.write("gibberish!")
os.fsync(f.fileno()) # Ensures data is written to disk
os.fsync(f.fileno()) is called to make sure the data is immediately written to the disk and not left in the buffer.
os.fsync() takes file descriptor that’s why we passed f.fileno() which is a unique integer assigned by the system to the file on which we are operating.
If you’re creating CLI tools, formatting the output to fit the terminal width can make the output cleaner. os.get_terminal_size() gives you the current terminal width and height, making it easy to dynamically format content.
import os
size = os.get_terminal_size()
print(f"Terminal Width: {size.columns}, Terminal Height: {size.lines}")
When we run this code in the terminal, we get the size of the terminal on which we are running this script.
PS > py sample.py Terminal Width: 158, Terminal Height: 12
Note: You may get an error when directly running the script on IDE where the program doesn’t have access to the terminal.
?Other articles you might be interested in if you liked this one
✅Streaming videos on the frontend in FastAPI.
✅How to fix circular imports in Python.
✅Template inheritance in Flask.
✅How to use type hints in Python?
✅How to find and delete mismatched columns from datasets in pandas?
✅How does the learning rate affect the ML and DL models?
That’s all for now.
Keep Coding✌✌.
以上是Python 中有用但很少使用的作業系統函數的詳細內容。更多資訊請關注PHP中文網其他相關文章！
