วิธีรวมไฟล์ใน Python การเขียนข้อมูลลงไฟล์. การจัดการไฟล์ขั้นสูงใน Python

Python รองรับหลายอย่าง หลากหลายชนิดไฟล์ แต่ตามเงื่อนไขสามารถแบ่งออกเป็นสองประเภท: ข้อความและไบนารี ไฟล์ข้อความได้แก่ ไฟล์ที่มีนามสกุล cvs, txt, html โดยทั่วไปไฟล์ใดๆ ก็ตามที่บันทึกข้อมูลไว้ แบบฟอร์มข้อความ- ไฟล์ไบนารี่ ได้แก่ ไฟล์รูปภาพ เสียง และวิดีโอ เป็นต้น การใช้งานอาจแตกต่างกันเล็กน้อยขึ้นอยู่กับประเภทของไฟล์

เมื่อทำงานกับไฟล์ คุณต้องปฏิบัติตามลำดับการดำเนินการบางอย่าง:

การเปิดไฟล์โดยใช้เมธอด open()

การอ่านไฟล์โดยใช้วิธี read() หรือการเขียนไฟล์โดยใช้วิธี write()

การปิดไฟล์โดยใช้เมธอด close()

การเปิดและปิดไฟล์

ในการเริ่มทำงานกับไฟล์ คุณต้องเปิดไฟล์โดยใช้ ฟังก์ชั่นเปิด() ซึ่งมีคำจำกัดความอย่างเป็นทางการดังต่อไปนี้:

เปิด(ไฟล์, โหมด)

พารามิเตอร์แรกของฟังก์ชันแสดงถึงเส้นทางไปยังไฟล์ เส้นทางของไฟล์อาจเป็นค่าสัมบูรณ์ กล่าวคือ เริ่มต้นด้วยอักษรระบุไดรฟ์ เช่น C://somedir/somefile.txt หรือคุณสามารถเชื่อมโยงได้ เช่น somedir/somefile.txt - ในกรณีนี้ ไฟล์จะถูกค้นหาโดยสัมพันธ์กับตำแหน่ง กำลังรันสคริปต์หลาม

อาร์กิวเมนต์ที่สองผ่านไป - โหมดจะตั้งค่าโหมดการเปิดไฟล์ขึ้นอยู่กับสิ่งที่เราจะทำอย่างไรกับมัน มี 4 โหมดทั่วไป:

ร (อ่าน) ไฟล์ถูกเปิดเพื่อการอ่าน หากไม่พบไฟล์ ข้อยกเว้น FileNotFoundError จะถูกส่งออกไป

ก (เขียน) ไฟล์ถูกเปิดเพื่อเขียน หากไม่มีไฟล์อยู่ ไฟล์นั้นจะถูกสร้างขึ้น หากมีไฟล์ที่คล้ายกันอยู่แล้ว ไฟล์นั้นจะถูกสร้างขึ้นใหม่ และข้อมูลเก่าในนั้นจะถูกลบทิ้งไป

ก(ผนวก) ไฟล์ถูกเปิดเพื่อการเขียนเพิ่มเติม หากไม่มีไฟล์อยู่ ไฟล์นั้นจะถูกสร้างขึ้น หากมีไฟล์ที่คล้ายกันอยู่แล้ว ข้อมูลจะถูกเขียนไปที่ส่วนท้ายของไฟล์

การเขียนข้อมูลลงในไฟล์ Python

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

ข (ไบนารี) ใช้เพื่อทำงานกับไฟล์ไบนารี ใช้ร่วมกับโหมดอื่น - w หรือ r

หลังจากทำงานกับไฟล์เสร็จแล้ว จะต้องปิดไฟล์โดยใช้เมธอด close() วิธีการนี้จะปล่อยทรัพยากรที่ใช้ทั้งหมดที่เกี่ยวข้องกับไฟล์

ตัวอย่างเช่น ลองเปิดไฟล์ข้อความ "hello.txt" เพื่อเขียน:

Myfile = open("hello.txt", "w") myfile.close()

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

ในกรณีนี้เราสามารถจัดการกับข้อยกเว้นได้:

ลอง: somefile = open("hello.txt", "w") ลอง: somefile.write("hello world") ยกเว้นข้อยกเว้นเป็น e: print(e) ในที่สุด: somefile.close() ยกเว้นข้อยกเว้นเช่น ex: print( อดีต)

ใน ในกรณีนี้งานทั้งหมดกับไฟล์เกิดขึ้นในบล็อกลองแบบซ้อน และหากมีข้อยกเว้นเกิดขึ้นอย่างกะทันหัน ไม่ว่าในกรณีใดไฟล์จะถูกปิดในบล็อกสุดท้าย

อย่างไรก็ตามยังมีอีกมาก การออกแบบที่สะดวก- มีการก่อสร้าง:

ด้วย open(file, mode) as file_obj: Instructions

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

ลองเขียนตัวอย่างก่อนหน้านี้ใหม่:

ด้วย open("hello.txt", "w") เป็น somefile: somefile.write("hello world")

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

วันนี้เราจะครอบคลุมหัวข้อต่อไปนี้

1. วิธีการเปิดไฟล์.
2. วิธีการไฟล์พื้นฐาน
3. มาตรฐาน I/O
4. การเข้าถึงแบบสุ่ม.
5. การทำงานแบบทีละบรรทัดกับไฟล์
6. กำลังปิดไฟล์.
7. การวนซ้ำ
8. การดอง
9. ไฟล์ไบนารี – โมดูลโครงสร้าง
10. การทำงานกับระบบไฟล์

1. วิธีการเปิดไฟล์

คุณสามารถเปิดไฟล์โดยใช้ฟังก์ชั่นเปิด:

เปิด (ชื่อ [, โหมด [, การบัฟเฟอร์]])

ฟังก์ชั่นส่งกลับวัตถุไฟล์ ต้องใช้เฉพาะอาร์กิวเมนต์แรกเท่านั้น หากไม่มีพารามิเตอร์อื่น ไฟล์จะสามารถอ่านได้ ตารางโหมดของฟังก์ชันเปิด:

“ร” – การอ่าน

"w" – บันทึก

“ก” – นอกจากนี้

"b" – โหมดไบนารี

"+" – อ่าน/เขียน

สามารถเพิ่มโหมด "+" ให้กับโหมดอื่นได้ ตามค่าเริ่มต้น Python จะเปิดไฟล์ต่างๆ โหมดข้อความ- หากต้องการเปิดไฟล์ในโหมดไบนารี่เพื่ออ่าน คุณสามารถเพิ่ม "rb" ได้ พารามิเตอร์ตัวที่สามกำหนดขนาดบัฟเฟอร์เมื่อทำงานกับไฟล์ ตามค่าเริ่มต้น ระบบจะปิดใช้งาน และการอ่าน/เขียนจะไปจากดิสก์หนึ่งไปอีกดิสก์หนึ่งโดยตรง หากต้องการเปิดใช้งานบัฟเฟอร์ พารามิเตอร์ที่สามจะต้องไม่เป็นศูนย์

2. วิธีการไฟล์พื้นฐาน

ใน Python วัตถุจำนวนมากเป็นไฟล์: อินพุตมาตรฐานคือ sys.stdin เอาต์พุตมาตรฐาน sys.stdout วัตถุที่เปิดโดยฟังก์ชัน urllib.urlopen ฯลฯ

เขียนลงไฟล์:

>>> f = open("my_file", "w") >>> f.write("Hello, ") >>> f.write("World!") >>> f.close()

>>> f = open("my_file", "r") >>> f.read(5) "Hello" >>> f.read() ", World!"

3. I/O มาตรฐาน

ใน บรรทัดคำสั่งคุณสามารถเขียนหลายคำสั่งในแถวโดยส่งผ่านผลลัพธ์ของงานจากคำสั่งหนึ่งไปยังอีกคำสั่งหนึ่งผ่านไปป์ไลน์ - หรือไปป์:

แมว my_file | หลาม test.py

คำสั่งแรก cat เขียนเนื้อหาของไฟล์ข้อความ my_file ไปยังเอาต์พุตมาตรฐานของ sys.stdout คำสั่งที่สองรันไฟล์ Python ที่อ่านอินพุตมาตรฐาน sys.stdin นับจำนวนคำในไฟล์ และพิมพ์ผลลัพธ์:

test.py: นำเข้า sys text = sys.stdin.read() คำ = text.split() wordcount = len(คำ) พิมพ์ "Wordcount:", wordcount

ช่องสัญญาณหรือไปป์เป็นโครงสร้างที่รวมเอาต์พุตมาตรฐานเข้าด้วยกัน อินพุตมาตรฐานและอนุญาตให้มีการแลกเปลี่ยนข้อมูลระหว่างสองทีม

4. การเข้าถึงแบบสุ่ม

ตามค่าเริ่มต้น เมธอด read() จะอ่านข้อมูลตามลำดับตั้งแต่ต้นจนจบไฟล์ สำหรับ การเข้าถึงแบบสุ่มมีฟังก์ชันการค้นหาสำหรับไฟล์:

แสวงหา (ชดเชย [จากไหน])

offset – ชดเชยเป็นไบต์ที่สัมพันธ์กับจุดเริ่มต้นของไฟล์

ที่ไหน - ค่าเริ่มต้น เท่ากับศูนย์บ่งชี้ว่าออฟเซ็ตนั้นสัมพันธ์กับจุดเริ่มต้นของไฟล์

>>> f = open(r"my_file", "w") >>> f.write("01234567890123456789") >>> f.seek(5) >>> f.write("Hello, World!") >>> f.close() >>> f = open(r"my_file") >>> f.read() "01234สวัสดีชาวโลก!89"

ฟังก์ชัน tell() ส่งกลับตำแหน่งไฟล์ปัจจุบัน

5. การทำงานแบบทีละบรรทัดกับไฟล์

โดยปกติแล้วเราจะจัดการกับไฟล์ข้อความ อ่านหนึ่งบรรทัด:

ฟังก์ชัน readline() ที่ไม่มีพารามิเตอร์จะอ่านทั้งบรรทัด การมีพารามิเตอร์บ่งชี้ถึงฟังก์ชันนั้น จำนวนสูงสุดอักขระของสตริงที่จะอ่าน อ่านทุกบรรทัดและส่งคืนรายการบรรทัด:

ไฟล์.readlines()

เขียนบรรทัดลงในไฟล์:

f = open(r"my_file") lines = f.readlines() f.close() lines = "นี่คือ my_file2 \n" # เปลี่ยนบรรทัดที่ 1 f = open(r"my_file2", "w") f .writelines (บรรทัด) f.close ()

6. การปิดไฟล์

มีวิธี close() เพื่อปิดไฟล์ โดยทั่วไปไฟล์จะปิดตัวเองหลังจากที่คุณออกจากโปรแกรม แต่ไฟล์จำเป็นต้องปิดด้วยตนเองด้วยเหตุผลหลายประการ

1. Python อาจบัฟเฟอร์การเขียนลงในไฟล์ข้อมูลของคุณ ซึ่งอาจทำให้เกิดผลกระทบและข้อผิดพลาดที่ไม่คาดคิด
2. ระบบปฏิบัติการมีการจำกัดจำนวนไฟล์ที่เปิดพร้อมกัน
3. เมื่อเข้าถึงไฟล์จาก สถานที่ที่แตกต่างกันทั้งการอ่านและการเขียนจะต้องซิงโครไนซ์ในเวลาเดียวกัน การดำเนินการไฟล์- การบัฟเฟอร์การเขียนอาจทำให้มีการเขียนเกิดขึ้นแล้ว แต่ยังไม่มีข้อมูลในไฟล์

เพื่อให้แน่ใจว่าไฟล์ถูกปิดแล้ว คุณสามารถใช้ try/finally block:

ลอง: # ที่นี่เราจะเขียนลงในไฟล์ในที่สุด: file.close()

คุณยังสามารถใช้ตัวจัดการบริบทซึ่งจะปิดไฟล์ต่อไป:

ด้วย open("my_file") เป็น somefile: do_something(somefile)

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

7. การวนซ้ำ

การวนซ้ำไฟล์คือ การดำเนินงานขั้นพื้นฐานและมีตัวเลือกมากมาย การใช้ฟังก์ชัน read() เพื่ออ่านไบต์:

f = open(ชื่อไฟล์) ในขณะที่ True: char = f.read(1) ถ้าไม่ใช่ char: แบ่งกระบวนการ(char) f.close()

การอ่านทีละบรรทัด ไฟล์ข้อความและฟังก์ชัน readline():

f = open(ชื่อไฟล์) ในขณะที่ True: line = f.readline() ถ้าไม่ใช่ line: break process(line) f.close()

ตัวไฟล์เองสามารถทำหน้าที่เป็นตัววนซ้ำได้:

8.การดอง

อ็อบเจ็กต์เกือบทุกชนิดสามารถจัดเก็บไว้ในดิสก์ได้ทุกเมื่อในชีวิต และอ่านจากดิสก์ในภายหลัง มีโมดูลดองสำหรับสิ่งนี้:

นำเข้าดอง t1 = s = Pickle.dumps(t1) t2 = Pickle.loads (s) พิมพ์ t2

มีความแตกต่างเล็กน้อยที่นี่: t1 และ t2 จะเป็นวัตถุสองชิ้นที่แตกต่างกัน แม้ว่าจะเหมือนกันก็ตาม

9. ไบนารี

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

ฟังก์ชั่นของโมดูลนี้:

แพ็ค (รูปแบบ, ค่า 1, ค่า 2 ... )

ส่งกลับสตริงที่มีค่า value1 ... บรรจุตามรูปแบบ จำนวนและประเภทของอาร์กิวเมนต์ต้องตรงกับค่าที่กำหนดโดยสตริงรูปแบบ

แกะ (รูปแบบ, สตริง)

แกะออก สตริงสตริงตาม รูปแบบและส่งคืนวัตถุจำนวนหนึ่ง

คำนวณขนาด(รูปแบบ)

ส่งกลับขนาดของโครงสร้าง (เช่น ความยาวของสตริง) ที่สอดคล้องกับรูปแบบ

ตารางรูปแบบหลัก

รูปแบบ C ประเภท Python ========================== c สตริงถ่านยาว 1 ? Bool bool i int integer l จำนวนเต็มยาว f float float d double float s char string

สัญลักษณ์รูปแบบอาจนำหน้าด้วยตัวเลขระบุจำนวนการทำซ้ำ ตัวอย่างเช่น สตริงรูปแบบ "4h" จะเทียบเท่ากับสตริง "hhhh" โดยสิ้นเชิง อักขระช่องว่างระหว่างอักขระรูปแบบจะถูกละเว้น แต่ไม่อนุญาตให้ใช้อักขระช่องว่างระหว่างตัวเลขและอักขระรูปแบบ

ตัวเลขที่อยู่หน้าอักขระรูปแบบ "s" จะถูกตีความว่าเป็นความยาวของสตริง ไม่ใช่จำนวนการซ้ำ นั่นคือ "10s" หมายถึงสตริงที่มีอักขระ 10 ตัว ในขณะที่ "10c" หมายถึง 10 คูณหนึ่งอักขระ

คุณสามารถเปลี่ยนลำดับไบต์ได้ด้วยตนเอง:

< - little-endian >- บิ๊กเอนด์

ในตัวอย่างต่อไปนี้ เราบรรจุตัวเลขสองตัวไว้ในโครงสร้าง - จำนวนเต็มและจำนวนทศนิยม ซึ่งเป็นสตริงที่มีอักขระห้าตัว แล้วเก็บไว้ใน ไฟล์ไบนารีแล้วแยกออกจากไฟล์:

จาก struct import * out = open("123.bin", "wb") format = "if5s" data = pack(format, 24,12.48,"12345") out.write(data) out.close() input = open("123.bin", "rb") data = input.read() input.close() format = "if5s" # ค่าจำนวนเต็มหนึ่งค่า,value2,value3 = unpack(format, data) # จดบันทึก "," ใน "ค่า": แกะออกเห็นได้ชัดว่าส่งคืนค่าการพิมพ์ n-uple print value2 print value3 print calcsize(format) >>> 24 >>> 12.4799995422 >>> 12345 >>> 13

10. การทำงานกับระบบไฟล์

โมดูลระบบปฏิบัติการมาตรฐานมีส่วนต่อประสานสำหรับการทำงานกับระบบไฟล์ แต่ละโปรแกรมมีไดเร็กทอรีปัจจุบัน ฟังก์ชัน os.getcwd ส่งคืนไดเร็กทอรีปัจจุบัน:

นำเข้าระบบปฏิบัติการ cwd = os.getcwd() พิมพ์ cwd

ตรวจสอบว่ามีไฟล์อยู่ในไดเร็กทอรีปัจจุบันหรือไม่:

os.path.exists("my_file")

แสดงรายการไฟล์และไดเร็กทอรีย่อยสำหรับไดเร็กทอรีที่กำหนด:

os.listdir (เส้นทาง)

ตัวอย่างต่อไปนี้แสดงรายการไฟล์และไดเร็กทอรีย่อยทั้งหมดซ้ำสำหรับไดเร็กทอรีที่กำหนด:

นำเข้า os def walk(dir): สำหรับชื่อใน os.listdir(dir): path = os.path.join(dir, name) if os.path.isfile(path): print path else: walk(path) walk( เส้นทาง)

ในตัวอย่างต่อไปนี้เราจะได้รับ ข้อมูลทางสถิติเกี่ยวกับไดเร็กทอรีปัจจุบัน: ขนาดไดเร็กทอรีทั้งหมดเป็นไบต์, จำนวนไฟล์, จำนวนไดเร็กทอรีย่อย ฟังก์ชั่นมาตรฐาน os.path.walk มีพารามิเตอร์สามตัว: directory, ฟังก์ชั่นที่กำหนดเอง, รายการที่จะนับ:

นำเข้าระบบปฏิบัติการ sys def getlocaldata(sms,dr,flst): สำหรับ f ใน flst: fullf = os.path.join(dr,f) ถ้า os.path.islink(fullf): ดำเนินการต่อ # อย่านับไฟล์ที่เชื่อมโยงหาก os.path.isfile(fullf): sms += os.path.getsize(fullf) sms += 1 else: sms += 1 def dtstat(dtroot): sums = # 0 ไบต์, 0 ไฟล์, 1 ไดเร็กทอรีจนถึงระบบปฏิบัติการ .path.walk(dtroot,getlocaldata,sums) ส่งคืนรายงานผลรวม = dtstat(".") พิมพ์รายงาน

ตัวอย่างต่อไปนี้เป็นการตีความ ยูทิลิตี้ระบบเกรป ในไดเร็กทอรีปัจจุบันจะพบไฟล์ที่มีนามสกุล Python ซึ่งจะพบไฟล์นั้น สตริงการค้นหา"นำเข้าระบบปฏิบัติการ":

import os, sys, fnmatch mask = "*.py" pattern = "import os" def walk(arg,dir,files): สำหรับไฟล์ในไฟล์: ถ้า fnmatch.fnmatch(file,mask): name = os.path เข้าร่วม (dir, ไฟล์) ลอง: data = open(name,"rb").read() if data.find(pattern) != -1: print name ยกเว้น: pass os.path.walk(".",walk ,)

บทสรุป

วันนี้เราได้เรียนรู้ว่า วัตถุไฟล์รองรับการอ่าน/เขียน สำหรับ การดำเนินการที่ถูกต้องไฟล์ข้อมูลจะต้องถูกปิดโดยทางโปรแกรม สามารถเปิดไฟล์ได้ใน โหมดต่างๆ- I/O มาตรฐานก็เป็นไฟล์เช่นกัน คุณสามารถอ่านและเขียนไฟล์ทีละบรรทัดได้ คุณสามารถใช้การวนซ้ำแบบไบต์และบรรทัดกับไฟล์ได้ วัตถุใด ๆ ที่สามารถบันทึกลงในดิสก์ได้ ช่วงเวลาที่พลเวลาในสถานะสุ่มและกู้คืนในภายหลังโดยการอ่านจากดิสก์ การอ่าน/การเขียนสามารถทำได้ในโหมดไบนารี โดยรักษาความเข้ากันได้กับโครงสร้างภาษา C เชื่อมต่อกับ ระบบปฏิบัติการช่วยให้คุณสามารถเขียนโปรแกรมขนาดกะทัดรัดที่เสริมได้ สาธารณูปโภคมาตรฐานระบบปฏิบัติการ.

ตัวอย่างที่ให้มาได้รับการทดสอบบน Python เวอร์ชัน 2.6