Os.Path.เข้าร่วมใน Python: คู่มือปฏิบัติพร้อมตัวอย่าง

เมื่อคุณสำรวจPythonและทำโครงการที่ซับซ้อนมากขึ้น คุณจะสังเกตเห็นว่าบางโครงการมีไฟล์จำนวนมาก การจัดการไฟล์เหล่านี้อาจทำให้ความคืบหน้าของคุณช้าลงและหันเหความสนใจของคุณ ซึ่งเป็นเหตุผลว่าทำไมการเรียนรู้วิธีจัดการเส้นทางไฟล์และไดเร็กทอรีโดยใช้ฟังก์ชัน Python จึงเป็นเรื่องสำคัญ ฟังก์ชั่นสำคัญอย่างหนึ่งในการบรรลุสิ่งนี้คือ os.path.join()

ฟังก์ชัน os.path.join() ช่วยให้คุณสามารถเข้าร่วมส่วนเส้นทางอย่างน้อยหนึ่งส่วนเพื่อสร้างเส้นทางที่สมบูรณ์ ทำให้แน่ใจว่ามีตัวคั่นไดเร็กทอรีหนึ่งตัวคั่นระหว่างส่วนที่ไม่ว่างแต่ละส่วน ยกเว้นส่วนสุดท้าย ด้วยวิธีนี้ คุณสามารถหลีกเลี่ยงชื่อพาธแบบฮาร์ดโค้ดได้ด้วยตนเอง

ในบทความนี้ เราจะสำรวจการใช้โมดูล os.path และวิธีสร้างเส้นทางที่ไม่ขึ้นกับแพลตฟอร์ม เรามาเริ่มกันที่ภาพรวมของ os.path.join!

สารบัญ

• ภาพรวมของ os.path.join
• ไวยากรณ์ของ os.path.join() คืออะไร?
• วิธีใช้ฟังก์ชัน os.path.join
• วิธีการทำงานกับเส้นทาง
  • 1. การต่อองค์ประกอบเส้นทางกับ os.path.join()
  • 2. เส้นทางสัมบูรณ์และสัมพัทธ์
• วิธีเข้าถึงไดเรกทอรีการทำงานปัจจุบันใน Python
• สร้างเส้นทางด้วย os.path.join ข้ามแพลตฟอร์มได้หรือไม่
• กรณีการใช้งานของ os.path.join() คืออะไร?
  • 1. การอ่านและเขียนไฟล์
  • 2. การสร้างไดเร็กทอรีใหม่
  • 3. รายชื่อไฟล์ในไดเร็กทอรี
  • 4. วนซ้ำเส้นทางด้วย For Loop
• ความคิดสุดท้าย

ภาพรวมของ os.path.join

os.path.joinเป็นเมธอดที่มีประโยชน์ในโมดูลos.path ของ Python ซึ่งช่วยให้คุณรวมเซ็กเมนต์พาธตั้งแต่หนึ่งเซกเมนต์ขึ้นไปเพื่อสร้างพาธระบบไฟล์ที่สมบูรณ์

สิ่งนี้มีประโยชน์เมื่อคุณทำงานกับไฟล์และไดเร็กทอรี เพราะมันช่วยสร้างพาธในลักษณะที่ไม่ขึ้นกับแพลตฟอร์มโดยไม่ต้องใช้ฮาร์ดโค้ด

เมื่อคุณใช้os.path.join()จะใช้พาธและพาธเป็นพารามิเตอร์ โดยที่พาธและคอมโพเนนต์ในพาธสามารถเป็นได้ทั้งสตริงหรือวัตถุไบต์ที่เป็นตัวแทนของพาธ

เมธอดเชื่อมพาธกับสมาชิกทั้งหมดของ*pathsเพื่อให้แน่ใจว่ามีตัวคั่นไดเร็กทอรีเพียงตัวเดียวที่ปรากฏขึ้นหลังจากแต่ละส่วนที่ไม่ว่าง ยกเว้นส่วนสุดท้าย

เราได้ระบุประเด็นสำคัญบางประการเพื่อให้คุณจำเกี่ยวกับos.path.join() :

• ช่วยให้คุณสร้างเส้นทางที่ไม่ขึ้นกับแพลตฟอร์มซึ่งทำงานในระบบปฏิบัติการต่างๆ

• วิธีการนี้จะดูแลการเพิ่มตัวคั่นไดเร็กทอรีที่จำเป็นโดยอัตโนมัติ (ไม่ว่าจะเป็นเครื่องหมายทับ/หรือเครื่องหมายแบ็กสแลชขึ้นอยู่กับระบบปฏิบัติการ) ระหว่างส่วนประกอบพาธ

• คุณสามารถใช้os.path.join()กับ เมธอด os อื่นๆ เช่นos.walk()เมื่อสร้างพาธของไฟล์หรือโฟลเดอร์

ต่อไปนี้คือตัวอย่างวิธีใช้os.path.join()เพื่อรวมไฟล์และโฟลเดอร์ไว้ในเส้นทางเดียว:

import os

path1 = "folder1"
path2 = "folder2"
filename = "helloworld.txt"

full_path = os.path.join(path1, path2, filename)
print(full_path)

ในตัวอย่างนี้os.path.join()ใช้เพื่อรวมfolder1 , folder2และexample_file.txtให้เป็นพาธเดียว ผลลัพธ์ที่ได้จะแสดงในภาพด้านล่าง:

os.path.join()ทำให้แน่ใจว่าคุณสามารถทำงานกับไฟล์และเส้นทางไดเร็กทอรีได้อย่างสะดวก

ตัวอย่างข้างต้นมีไว้เพื่อให้ภาพรวมของประโยชน์ของos.path.join( ) ในหัวข้อถัดไป เราจะดูไวยากรณ์ของos.path.join()เพื่อช่วยให้คุณเข้าใจตรรกะเบื้องหลังฟังก์ชันนี้ได้ดีขึ้น

ไวยากรณ์ของ os.path.join() คืออะไร?

ในส่วนนี้ เราจะกล่าวถึงไวยากรณ์และพารามิเตอร์ของ เมธอด os.path.join()ใน Python

ไวยากรณ์สำหรับการใช้os.path.join()เป็นดังนี้:

os.path.join(path, *paths)

เราได้แสดงรายการพารามิเตอร์หลักสำหรับคุณที่คุณจะต้องเข้าใจเมื่อใช้ฟังก์ชันนี้:

• เส้นทาง : นี่คือส่วนแรกของที่อยู่ของไฟล์หรือโฟลเดอร์ โดยปกติจะเป็นสตริง (ลำดับของตัวอักษร ตัวเลข หรือสัญลักษณ์) แต่อาจเป็นข้อมูลประเภทอื่นที่ทำหน้าที่เหมือนสตริงก็ได้

• *paths : นี่คือส่วนอื่นๆ ของไฟล์หรือที่อยู่ของโฟลเดอร์ที่คุณต้องการเพิ่มลงในส่วนแรก คุณสามารถเพิ่มส่วนได้มากเท่าที่คุณต้องการ เช่นเดียวกับส่วนแรก สิ่งเหล่านี้สามารถเป็นสตริงหรือข้อมูลประเภทอื่นๆ ที่ทำหน้าที่เหมือนสตริง

เมื่อใช้os.path.join()เมธอดจะเชื่อมต่อพาธที่ให้มาในขณะที่แทรกตัวคั่นที่เหมาะสม (เช่น/หรือ) ตามระบบของคุณ สิ่งนี้ทำให้มั่นใจได้ว่าเส้นทางที่รวมกันนั้นเข้ากันได้กับระบบปฏิบัติการของคุณและฟังก์ชัน Python อื่นๆ

ตอนนี้คุณรู้ไวยากรณ์ของ ฟังก์ชัน os.path.join()แล้ว มาดูโมดูล os ที่อนุญาตให้คุณใช้ฟังก์ชันนี้

วิธีใช้ฟังก์ชัน os.path.join

ในการเริ่มใช้ เมธอด os.path.joinในโปรแกรม Python คุณต้องนำเข้าโมดูลระบบปฏิบัติการที่จำเป็นก่อน os หมายความว่าเป็นฟังก์ชันที่ขึ้นกับระบบปฏิบัติการ

หากต้องการนำเข้าโมดูล os เพียงเพิ่มบรรทัดต่อไปนี้ที่ส่วนเริ่มต้นของสคริปต์ Python ของคุณ:

import os

เมื่อคุณอิมพอร์ตโมดูล os แล้วคุณสามารถใช้เมธอดต่างๆ รวมถึงos.path.join

วิธีนี้มีประโยชน์อย่างยิ่งสำหรับการรวมส่วนประกอบของเส้นทางอย่างชาญฉลาด ช่วยหลีกเลี่ยงปัญหาเกี่ยวกับการต่อเส้นทาง และทำให้โค้ดของคุณพกพาสะดวกและอ่านง่ายขึ้น

หากต้องการใช้os.path.joinคุณสามารถเรียกมันด้วยองค์ประกอบเส้นทางที่ต้องการเป็นอาร์กิวเมนต์:

combined_path = os.path.join(path1, path2)

เมื่อคุณรวมโมดูล os และเมธอด os.path.joinไว้ในโค้ดของคุณ คุณจะมั่นใจได้ว่าการจัดการพาธไฟล์ของคุณสอดคล้องและเชื่อถือได้ในแพลตฟอร์มต่างๆ

สิ่งสำคัญคือคุณต้องรู้วิธีทำงานกับ เส้นทางเมื่อใช้ฟังก์ชัน os.path.join() ในโค้ด Python ของคุณ

วิธีการทำงานกับเส้นทาง

ในส่วนนี้ เราจะดูส่วนประกอบต่างๆ ของเส้นทาง ซึ่งจะทำให้คุณสามารถสร้างหรือจัดการเส้นทางตามปัญหาที่เกิดขึ้นได้

โดยเฉพาะอย่างยิ่ง เราจะพิจารณาสิ่งต่อไปนี้:

1. การเชื่อมองค์ประกอบเส้นทางกับ os.path.join()

2. เส้นทางสัมบูรณ์และสัมพัทธ์

1. การต่อองค์ประกอบเส้นทางกับ os.path.join()

เมื่อทำงานกับไฟล์และไดเร็กทอรีใน Python คุณมักจะต้องจัดการชื่อพาธด้วยวิธีเข้าร่วม ฟังก์ชันos.path.join () เป็นเครื่องมือที่มีประโยชน์สำหรับจุดประสงค์นี้

ตัวอย่างต่อไปนี้แสดงวิธีเชื่อมต่อพาธโดยใช้เมธอด os.path.join:

import os

path1 = "home"
path2 = "your_directory"
filename = "your_file.txt"

fullpath = os.path.join(path1, path2, filename)
print(fullpath) 

ใน สคริปต์ Python นี้ เรากำลังจัดการเส้นทางของไฟล์โดยการรวมส่วน “/home”, “your_directory” และ “your_file.txt” เข้าด้วยกันโดยใช้ฟังก์ชัน os.path.join ( )

ผลลัพธ์คือสตริงเดียวที่สร้างพาธที่เชื่อมต่อกันอย่างสมบูรณ์ ซึ่งแสดงถึงตำแหน่งของ ไฟล์ your_file.txtในระบบ

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการจัดการและการแปลงใน Python โปรดดูวิดีโอต่อไปนี้:

2. เส้นทางสัมบูรณ์และสัมพัทธ์

เมื่อใช้ ฟังก์ชัน os.path.join()คุณสามารถทำงานกับทั้งพาธสัมบูรณ์และพาธสัมพัทธ์

เส้นทางสัมบูรณ์คือเส้นทางที่สมบูรณ์ซึ่งเริ่มต้นด้วยไดเร็กทอรีรากและรวมส่วนประกอบของชื่อพาธทั้งหมด

ต่อไปนี้คือตัวอย่างการทำงานกับส่วนประกอบพาธสัมบูรณ์โดยใช้ เมธอด os.path.join() :

import os

# Absolute path
abs_path1 = "/var/www"
abs_path2 = "html"
filename = "index.html"
full_abs_path = os.path.join(abs_path1, abs_path2, filename)
print(full_abs_path)  # "/var/www/html/index.html"

ในสคริปต์นี้ เรากำลังสร้างเส้นทางที่สมบูรณ์ไปยังไฟล์ชื่อ index.html ซึ่งอยู่ในไดเร็กทอรี html ภายใต้ /var/www

เราบรรลุเป้าหมายนี้โดยใช้ ฟังก์ชัน os.path.join()เพื่อรวม “/var/www”, “html” และ “index.html” ให้เป็นเส้นทางเดียวที่สมบูรณ์

เส้นทางสัมพัทธ์ระบุตำแหน่งของไฟล์หรือไดเร็กทอรีที่สัมพันธ์กับไดเร็กทอรีปัจจุบัน ต่อไปนี้คือตัวอย่างการทำงานกับพาธสัมพัทธ์ใน เมธอด os.path.join() :

import os

rel_path1 = ".."
rel_path2 = "other_directory"
filename = "example.txt"
full_rel_path = os.path.join(rel_path1, rel_path2, filename)
print(full_rel_path)  # "../other_directory/example.txt"

ในโค้ดนี้ เรากำลังสร้างพาธสัมพัทธ์ไปยังไฟล์ชื่อexample.txtในไดเร็กทอรีชื่อ other_directory ไดเร็กทอรีนี้เพิ่มขึ้นหนึ่งระดับจากไดเร็กทอรีปัจจุบัน ซึ่งแสดงด้วย “..”

เรากำลังใช้ ฟังก์ชัน os.path.join()เพื่อรวมส่วนเหล่านี้เข้าด้วยกันเป็นเส้นทางที่มีอยู่อย่างสมบูรณ์

องค์ประกอบที่สำคัญอีกอย่างหนึ่งของการทำงานกับไดเร็กทอรีคือการเข้าถึงไดเร็กทอรีการทำงานปัจจุบัน เมื่อคุณใช้ ฟังก์ชัน os.path.join()คุณจะเข้าถึงไดเร็กทอรีการทำงานปัจจุบันเป็นส่วนใหญ่ นี่เป็นเพราะไดเร็กทอรีการทำงานปัจจุบันทำหน้าที่เป็นจุดเริ่มต้นเมื่อสร้างไดเร็กทอรีใหม่

มาดูกันว่าคุณสามารถเข้าถึงไดเร็กทอรีการทำงานปัจจุบันได้อย่างไร!

วิธีเข้าถึงไดเรกทอรีการทำงานปัจจุบันใน Python

เมื่อทำงานกับพาธและไดเร็กทอรี คุณอาจเจอสถานการณ์ที่คุณต้องนำทางผ่านไดเร็กทอรีหรือเข้าถึงไฟล์จากตำแหน่งต่างๆ การทำความเข้าใจแนวคิดของไดเร็กทอรีการทำงานปัจจุบัน (CWD) เป็นสิ่งสำคัญสำหรับจุดประสงค์นี้

ไดเร็กทอรีการทำงานปัจจุบันคือโฟลเดอร์ที่สคริปต์ Python ของคุณกำลังดำเนินการอยู่

ในการรับไดเร็กทอรีการทำงานปัจจุบัน คุณสามารถใช้ ฟังก์ชัน os.getcwd()จาก โมดูล osตามที่แสดงในตัวอย่างโค้ดด้านล่าง:

import os

current_directory = os.getcwd()
print("Current working directory:", current_directory)

รหัสนี้ให้ไดเร็กทอรีการทำงานปัจจุบันแก่เราดังที่แสดงด้านล่าง:

สร้างเส้นทางด้วย os.path.join ข้ามแพลตฟอร์มได้หรือไม่

ใช่ ฟังก์ชัน os.path.join()ช่วยให้แน่ใจว่าคุณสร้างเส้นทางไฟล์ในลักษณะที่พกพาได้ โดยไม่คำนึงถึงระบบปฏิบัติการพื้นฐาน

ฟังก์ชันนี้จะดูแลการใช้ตัวคั่นไดเร็กทอรีที่ถูกต้องสำหรับแพลตฟอร์มปัจจุบัน ทำให้โค้ดของคุณสามารถปรับเปลี่ยนและบำรุงรักษาได้มากขึ้น

ตัวอย่างเช่น ยกตัวอย่างต่อไปนี้ที่เรารวมพาธและไฟล์โดยใช้os.path.join() :

import os

path = os.path.join('directory1', 'directory2', 'file.txt')
print(path)

ในขณะที่เขียน เราใช้ระบบปฏิบัติการ Windows และผลลัพธ์มีลักษณะดังนี้:

ผลลัพธ์จะแสดงโฮมไดเร็กทอรีของผู้ใช้ปัจจุบัน

อย่างไรก็ตาม หากคุณใช้ระบบปฏิบัติการ Unix ผลลัพธ์ของคุณจะมีลักษณะดังนี้:

/directory2/file.txt

ในตัวอย่างข้างต้น คุณจะเห็นว่าตัวคั่นไดเร็กทอรีนั้นแตกต่างกันไปตามระบบปฏิบัติการ ซึ่งแสดงให้เห็นว่าos.path.join()จัดการความแตกต่างให้คุณโดยอัตโนมัติ อย่างไร

ตอนนี้คุณคุ้นเคยกับส่วนประกอบที่สำคัญของ ฟังก์ชัน os.path.join()แล้ว มาดูตัวอย่างและกรณีการใช้งานของฟังก์ชันนี้กัน

กรณีการใช้งานของ os.path.join() คืออะไร?

ในส่วนนี้ เราจะสำรวจตัวอย่างวิธีใช้os.path.join()ในโครงการ Python ของคุณ ตัวอย่างเหล่านี้จะช่วยให้คุณเข้าใจได้ดีขึ้นว่าเมื่อใดควรใช้ ฟังก์ชัน os.path.join()ในโค้ดของคุณ

1. การอ่านและเขียนไฟล์

เมื่อคุณทำงานกับไฟล์ คุณมักจะต้องระบุเส้นทางที่สมบูรณ์ไปยังไฟล์ เส้นทางนี้อาจต้องสร้างแบบไดนามิก โดยขึ้นอยู่กับปัจจัยต่างๆ เช่น ระบบปฏิบัติการของผู้ใช้ ไดเร็กทอรีการทำงานปัจจุบัน หรืออินพุตของผู้ใช้

os.path.join()ช่วยคุณสร้างเส้นทางเหล่านี้ด้วยวิธีที่เชื่อถือได้และไม่ขึ้นกับแพลตฟอร์ม

ต่อไปนี้คือตัวอย่างการอ่านและเขียนไฟล์โดยใช้os.path.join() :

directory = input("Enter the directory where the file is stored: ")
filename = input("Enter the filename: ")
path = os.path.join(directory, filename)

with open(path, 'r') as file:
    print(file.read())

ในสคริปต์นี้ เราขอให้ผู้ใช้ป้อนไดเร็กทอรีและชื่อไฟล์ จากนั้นเราใช้os.path.join()เพื่อสร้างเส้นทางแบบเต็มไปยังไฟล์ หลังจากนั้น เราจะเปิดไฟล์นี้ในโหมดอ่านและพิมพ์เนื้อหาออกมา

2. การสร้างไดเร็กทอรีใหม่

เมื่อคุณสร้างไดเร็กทอรีใหม่โดยใช้os.makedirs()คุณสามารถใช้os.path.join()เพื่อสร้างพาธไปยังไดเร็กทอรีใหม่

ต่อไปนี้คือตัวอย่างการสร้างไดเร็กทอรีใหม่ด้วยos.path.join() :

base_directory = "/tmp"
new_directory = "my_new_directory"
path = os.path.join(base_directory, new_directory)
os.makedirs(path, exist_ok=True)

ในสคริปต์นี้ เรากำลังสร้างพาธไปยังไดเร็กทอรี ใหม่ ชื่อ my_new_directory ภายใต้ไดเร็กทอรี /tmp จากนั้นเราใช้os.makedirs()เพื่อสร้างไดเร็กทอรีใหม่นี้ในระบบของเรา หากยังไม่มี

3. รายชื่อไฟล์ในไดเร็กทอรี

หากคุณต้องการแสดงรายการไฟล์ทั้งหมดบางประเภทในไดเร็กทอรี คุณสามารถใช้os.path.join()เพื่อสร้างพาธไปยังแต่ละไฟล์

ตัวอย่างต่อไปนี้สาธิตการสร้างพาธไปยังไฟล์ทั้งหมดโดยใช้os.path.join() :

directory = "E:ospathjoin"
for filename in os.listdir(directory):
    if filename.endswith(".txt"):
        path = os.path.join(directory, filename)
        print(path)

ในสคริปต์นี้ เรากำลังสแกนไฟล์ทั้งหมดในไดเร็กทอรีที่ระบุE :ospathjoinโดยใช้for loop

สำหรับแต่ละไฟล์ที่ลงท้ายด้วย ".txt" เราจะรวมไดเร็กทอรีและชื่อไฟล์เพื่อสร้างพาธแบบเต็ม จากนั้นเราจะพิมพ์

4. วนซ้ำเส้นทางด้วย For Loop

คุณยังสามารถใช้ for loop เพื่อวนซ้ำส่วนประกอบพาธตั้งแต่สองพาธขึ้นไปและเข้าร่วมโดยใช้os.path.join สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อทำงานกับรายการ ยาว หรือไดเร็กทอรีที่ซ้อนกันหลายไดเร็กทอรี ตัวอย่างเช่น:

import os

paths = ["folder1", "folder2", "folder3", "file.txt"]
combined_path = ""

for p in paths:
    combined_path = os.path.join(combined_path, p)

print(combined_path)

ในสคริปต์นี้ เรากำลังสร้างเส้นทางไปยังไฟล์ชื่อfile.txtซึ่งอยู่ภายในชุดไดเร็กทอรีที่ซ้อนกัน ( folder1, folder2, folder3 ) เราทำสิ่งนี้โดยการรวมแต่ละส่วนของเส้นทางตามลำดับโดยใช้os.path.join()และวิธีการส่งคืนเส้นทางที่พิมพ์ออกมา

ความคิดสุดท้าย

os.path.join()เป็นส่วนสำคัญของภาษาโปรแกรม Python เมื่อต้องจัดการกับไฟล์และเส้นทางไดเรกทอรี ความสามารถในการจัดการเส้นทางในลักษณะที่เข้ากันได้กับระบบปฏิบัติการทั้งหมดเป็นทักษะสำคัญที่ควรมี ทำให้มั่นใจได้ว่ารหัสของคุณมีแนวโน้มที่จะเกิดข้อผิดพลาดน้อยลง

นอกจากนี้ การทำความเข้าใจและใช้งานos.path.join()จะช่วยให้คุณโต้ตอบกับระบบไฟล์ได้ เช่น การอ่านจากไฟล์ การเขียนไปยังไฟล์ การสร้างไดเร็กทอรี และอื่นๆ

เมื่อคุณเดินทางต่อไปในการเขียนโปรแกรม Python คุณจะพบว่าos.path.join()มีประโยชน์เมื่อทำงานกับไดเร็กทอรี ยิ่งใช้ ยิ่งเห็นคุณค่าของมัน การเรียนรู้และฝึกฝนฟังก์ชันนี้ให้เชี่ยวชาญ คุณกำลังก้าวไปข้างหน้าอย่างสำคัญในการเป็นโปรแกรมเมอร์ Python ที่เชี่ยวชาญยิ่งขึ้น!