📚 Python: მუშაობა ფაილებთან (File I/O)¶

ფაილებთან მუშაობა არის პროგრამირების ფუნდამენტური ნაწილი — ის საშუალებას გვაძლევს ფაილების წაკითხვა, ჩაწერა, წაშლაზე და დამუშავებაზე.

1. საბაზისო ოპერაციები ფაილებთან¶

1.1. ფაილის გახსნა და დახურვა: `open()` და `close()`¶

ფაილზე ნებისმიერი ოპერაციის დაწყებამდე ის უნდა გაიხსნას ჩაშენებული ფუნქცია open()-ით, რომელიც აბრუნებს ფაილის ობიექტს.

სინტაქსი:

file_object = open(filename, mode)

მიმოხილვა:

რეჟიმი	აღწერა	ქმედება
`'r'`	კითხვა (read)	ნაგულისხმევი; ფაილი უნდა არსებობდეს
`'w'`	ჩაწერა (write)	ქმნის ახალ ფაილს ან წაშლის არსებულ შიგთავსს
`'a'`	დამატება (append)	ჩაწერა ფაილის ბოლოს; ქმნის ფაილს, თუ არ არსებობს
`'r+'`	კითხვა და ჩაწერა	ფაილი უნდა არსებობდეს; პოზიცია იწყება თავიდან
`'w+'`	ჩაწერა და კითხვა	ქმნის ან შლის არსებული შიგთავსს
`'a+'`	დამატება და კითხვა	კითხვა იწყება თავიდან, ჩაწერა — ბოლოდან

ყურადღება

ოპერაციის დასრულების შემდეგ საჭიროა ფაილის დახურვა close()-ით, რათა განთავისუფლდეს რესურსები და დაიწყოს ყველა ცვლილების შენახვა.

დაუკვირდი

შეიძლება encoding="utf-8" გჭირდება თუ ფაილში ჩაწერ ან წაიკითხავ უნიკოდირება განსხვავებულ ტექსტს.

მაგალითი 1: ფაილის გახსნა და დახურვა¶

# ფაილის გახსნა ჩაწერის რეჟიმში
file = open("test_file.txt", "w")
# ... ოპერაციები ...
file.close()
print("ფაილი 'test_file.txt' შეიქმნა და დაიხურა.")

1.2. უსაფრთხო მუშაობა: `with` ოპერატორი¶

with კონსტრუქცია უზრუნველყოფს ავტომატურ დახურვას, თუნდაც ბლოკში გამოვიდეს გამონაკლისი. რეკომენდებულია Python-ში.

მაგალითი 2: `with` გამოყენება¶

with open("safe_file.txt", "w", encoding="utf-8") as f:
    f.write("ამ ტექსტს ჩავწერთ ფაილში.\n")
# ფაილი ავტომატურად დაიხურა
print("ფაილი ავტომატურად დაიხურა.")

2. მონაცემების ჩაწერა ფაილში¶

საუკეთესო მეთოდები: - write(string) — წერს სტრიქონს და აბრუნებს ჩაწერილი სიმბოლოების რაოდენობას. - writelines(list_of_strings) — წერს სტრიქონების სიას (არ სძენს \n თავისით).

მაგალითი 3: `write()` გამოყენება¶

with open("data_write.txt", "w", encoding="utf-8") as f:
    f.write("პირველი ხაზი.\n")
    f.write("მეორე ხაზი.\n")
    print("მესამე ხაზი (ბეჭდვა ფაილში)", file=f)
print("ჩაწერა დასრულდა.")

Note

with open("data_write.txt", "w") as f:
open(...) – ხსნის ფაილს სახელით data_write.txt.
"w" – ნიშნავს write mode–ს (ჩაწერა).
თუ ფაილი არ არსებობს — შექმნის, თუ არსებობს — ანულებს არსებულ კონტენტს.
with ... as f – ქმნის კონტექსტის მენეჯერს:
ამ ბლოკის დახურვისას ფაილი ავტომატურად დაიხურება.
არ გჭირდება f.close().
ამ ხაზის შემდეგ გვაქვს ფაილის ობიექტი f, რომელშიც შეგვიძლია ჩაწერა.
f.write("პირველი ხაზი.\n")
f.write() წერს ტექსტს ფაილში.
"პირველი ხაზი.\n"
"პირველი ხაზი." — ჩაწერილი ტექსტი
\n — ახალი ხაზის სიმბოლო (Enter).
f.write("მეორე ხაზი.\n")
ანალოგიურად: მეორე ხაზი იწერება ფაილში, შემდეგ — ახალი ხაზი.
print("მესამე ხაზი (ბეჭდვა ფაილში)", file=f)
ჩვეულებრივ, print() ბეჭდავს ეკრანზე.
მაგრამ როცა ვუთითებთ file=f, ეს ნიშნავს:
ბეჭდვა ეკრანის ნაცვლად მოხდება ფაილში.
ამ შემთხვევაში "მესამე ხაზი (ბეჭდვა ფაილში)" ჩაიწერება ფაილში როგორც ტექსტი და ასევე ავტომატურად დაემატება ახალი ხაზიც.
print("ჩაწერა დასრულდა.")
ეს print ეკრანზე ბეჭდავს ტექსტს, რადგან file=f არ არის მითითებული.
ფაილს არანაირ კავშირში არ არის.
🔚 შედეგად ფაილში data_write.txt ჩაიწერება ასეთი შინაარსი:
პირველი ხაზი.
მეორე ხაზი.
მესამე ხაზი (ბეჭდვა ფაილში)
ეკრანზე კი დაიბეჭდება:
ჩაწერა დასრულდა.

მაგალითი 4: `writelines()` გამოყენება¶

lines = ["ხაზი 1\n", "ხაზი 2\n", "ხაზი 3\n"]
with open("data_writelines.txt", "w") as f:
    f.writelines(lines)
print("writelines დასრულდა.")

მაგალითი 5: დამატება (`'a'`)¶

with open("data_append.txt", "w", encoding="utf-8") as f:
    f.write("ეს იყო საწყისი ხაზი.\n")

with open("data_append.txt", "a", encoding="utf-8") as f:
    f.write("ეს დაემატა მოგვიანებით.\n")

print("დამატება დასრულდა.")

3. მონაცემების კითხვა ფაილიდან¶

მთავარი მეთოდები: - read(size) — კითხულობს size სიმბოლოს; თუ size არ არის, კითხულობს მთელ ფაილს.
- readline() — კითხულობს ერთ ხაზს.
- readlines() — აბრუნებს ყველა ხაზს სიაში.

მაგალითი 6: `read()` — მთელი შიგთავსი¶

with open("read_example.txt", "w") as f:
    f.write("პირველი ხაზი.\nმეორე ხაზი.\nმესამე ხაზი.")

with open("read_example.txt", "r") as f:
    content = f.read()
    print("--- მთელი ფაილი ---\n", content)

მაგალითი 7: `readline()` — თითო ხაზზე¶

with open("read_example.txt", "r") as f:
    first_line = f.readline().strip()
    second_line = f.readline().strip()
    print(f"პირველი ხაზი: {first_line}")
    print(f"მეორე ხაზი: {second_line}")

მაგალითი 8: `readlines()` — სიის სახით¶

with open("read_example.txt", "r") as f:
    lines_list = f.readlines()
    for line in lines_list:
        print(line.strip())

3.1. ფაილის იტერაცია¶

დიდი ფაილების ეფექტური დამუშავებისათვის გამოიყენეთ ფაილის პირდაპირი იტერაცია — თითო ხაზზე კითხვა.

მაგალითი 9: იტერაცია¶

with open("read_example.txt", "r") as f:
    for i, line in enumerate(f):
        print(f"ხაზი {i+1}: {line.strip()}")

4. ფაილური სისტემის მანიპულაცია: `os` და `shutil`¶

ზოგადი ფუნქციები:

მოდული	ფუნქცია	აღწერა
os	`os.rename(old, new)`	გადარქმევა
os	`os.remove(path)`	ფაილის წაშლა
os	`os.mkdir(path)`	დირექტორიის შექმნა
os.path	`os.path.exists(path)`	არსებობს თუ არა
shutil	`shutil.copy(src, dst)`	კოპირება
shutil	`shutil.move(src, dst)`	გადატანა / გადარქმევა
shutil	`shutil.rmtree(path)`	დირექტორიის და მის შიგთავსის წაშლა

მაგალითი 10: გადარქმევა¶

import os

with open("old_name.txt", "w") as f:
    f.write("Hello")

os.rename("old_name.txt", "new_name.txt")
print("ფაილს დაერქვა სახელი: new_name.txt")

მაგალითი 11: წაშლა¶

import os

if os.path.exists("new_name.txt"):
    os.remove("new_name.txt")
    print("ფაილი 'new_name.txt' წაიშალა.")
else:
    print("ფაილი არ არსებობდა.")

5. პრაქტიკული დავალებები¶

შექმენი ტექსტური ფაილი და ჩაწერე შენი სახელი.

წაიკითხე ფაილის შიგთავსი და დაბეჭდე ეკრანზე.

ჩაწერე 3 სტრიქონი და შემდეგ პროგრამაში თითოეული გამოყავი ცალ-ცალკე.

დაწერე პროგრამა, რომელიც ითვლის ფაილში სტრიქონების რაოდენობას.

დაწერე პროგრამა, რომელიც ითვლის სიმბოლოების რაოდენობას.

დაამატე ტექსტი ფაილში ისე, რომ არსებული არ წაიშალოს.

ჩაწერე list ფაილში writelines()-ით.

წაიკითხე ფაილი და დაბეჭდე მხოლოდ სტრიქონები, რომლებიც შეიცავს სიტყვას „Python“.

შეამოწმე ფაილის არსებობა და მხოლოდ ამის შემდეგ წაიკითხე.

წაიკითხე ფაილი და გამოყავი მხოლოდ პირველი 5 სიმბოლო.

ჩაწერე რიცხვების სია ფაილში, შემდეგ წაიკითხე და გამოთვალე ჯამი.

ფაილში ჩაწერე 10 რიცხვი, შემდეგ პროგრამამ უნდა იპოვოს მაქსიმუმი.

შექმენი ორი ფაილი და მესამე ფაილში ჩაწერე მათი შიგთავსის გაერთიანება.

გადაკოპირე ფაილი shutil.copy()-ით.

დაწერე პროგრამა, რომელიც ფაილში ცვლის სიტყვა „cat“-ს სიტყვით „dog“.

წაიკითხე CSV და დაბეჭდე მხოლოდ ასაკი.

CSV-ში დაამატე ახალი მწკრივი.

JSON ფაილში შეცვალე ერთი value და კვლავ ჩაწერე.

პროგრამამ ფაილში ჩაწეროს 100 შემთხვევითი რიცხვი.

პროგრამამ წაიკითხოს ეს რიცხვები და დახარისხებული გამოყოს.

საწყისი ნაწილი I — საბაზისო ოპერაციები (open, write, read, close, with)
1. შეიქმნას homework.txt და ჩაწეროს სახელი (w) — გამოიყენეთ with და f.write().
2. წაიკითხოს მთელი შიგთავსი და დაბეჭდოს (f.read()).
3. დაამატოს გვარი ახალ ხაზზე (a).
4. ჩამოაყალიბოს 5 სტრიქონიანი სია და ჩაწეროს list_data.txt writelines()-ით (ხედით \n).
5. წაიკითხოს list_data.txt readline()-ით 3-ჯერ და დაბეჭდოს.
6. წაიკითხოს list_data.txt readlines()-ით და დაბეჭდოს სია (.strip()).
7. შექმნას numbers.txt და ჩაწეროს 1–10, თითო რიცხვი ახალ ხაზზე.
8. წაიკითხოს numbers.txt და დაბეჭდოს მხოლოდ ლუწი რიცხვები (ფაილის იტერაცია).
9. დაწეროს ფუნქცია safe_write(filename, content) რომელიც იყენებს with open(..., 'w').
10. დაწეროს ფუნქცია read_and_print(filename) — აცნობოს FileNotFoundError.

კითხვა/ჩაწერა, მონაცემთა დამუშავება
11. შექმნას scores.txt (სახელი,ქულა) — 5 ჩანაწერი.
12. წაიკითხოს scores.txt და გამოითვალოს საშუალო ქულა (.split(','), int()).
13. შექმნას passed.txt — ჩაიწეროს მხოლოდ ქულა > 70.
14. ჩაწეროს log.txt მიმდინარე დრო პროგრამის გაშვებისას (datetime.datetime.now()).
15. დაწეროს replace_text(filename, old_word, new_word) (თემპორალური ფაილი ან მთლიანად მეხსიერებაში).
16. შექმნას settings.ini და ჩაწეროს კონფიგი (მაგ. username=admin\nmax_attempts=5) და წაიკითხოს ლექსიკონში.
17. პროგრამა: ინსტრუმენტის გამოყენებით მიიღოს მომხმარებლის სტრიქონები და შეინახოს user_input.txt ვიდრე არ შეიყვანებს "დასრულება".
18. წაიკითხოს user_input.txt და დათვალოს ხაზების რაოდენობა.
19. შექმნას ცარიელი ფაილი empty.txt.
20. შეამოწმოს, რომ f.read() ბრუნებს '' (ცარიელი სტრიქონი).

ფაილური სისტემის მანიპულაცია (os, shutil)
21. შექმნას დირექტორია temp_files (os.mkdir()).
22. შექმნას temp_files/draft.txt.
23. გადარქვას draft.txt → final.txt (os.rename()).
24. შეამოწმოს os.path.exists('temp_files/final.txt').
25. დააკოპიროს final.txt როგორც backup.txt (shutil.copy()).
26. გადაინაცვლოს backup.txt ერთი დირექტორიით უკან (shutil.move()).
27. წაშალოს backup.txt (os.remove()).
28. წაშალოს temp_files/final.txt.
29. წაშალოს დირექტორია temp_files (დირექტორიაში არ უნდა იყოს ფაილები) — os.rmdir(). 30. შექმნას safe_delete(path) რომელიც უხეშად არ დაამშლის თუ ფაილი არ არსებობს (try/except FileNotFoundError ან os.path.exists()).
31. პროგრამა: შექმნას დირექტორია logs (თუ არ არსებობს) და სულ 10 ფაილი file_1.txt–დან file_10.txt (os.makedirs() და for).
32. წაშალოს 31-ის მიერ შექმნილი ფაილები და დირექტორია (shutil.rmtree()).

6. განხილვა / დისკუსია¶

რატომ არის with open(...) რეკომენდებული?
with ქმნის კონტექსტის მენეჯერს, რომლის __exit__ მეთოდი ყოველთვის ირჩევა ბლოკის შემდეგ და ავტომატურად ხურავს ფაილს — გარანტირებს რესურსების გათავისუფლებასა და მონაცემთა მთლიანობას, თუნდაც წარუმატებლობის დროს.
რა საფრთხეებით აღიქმება 'w' (Write) რეჟიმი?
'w' ამოწმებს ან ქმნის ფაილს და შლის არსებულ შიგთავსს — გამოიყენეთ უკიდურესად ფრთხილად; თუ საჭიროა შენარჩუნება, გამოიყენეთ 'a' ან წაიკითხეთ და შემდეგ ჩაიწერეთ ხელახლა.
რა განსხვავებაა read(), readline() და readlines() მეხსიერების გამოყენების თვალსაზრისით?
read() და readlines() იტვირთიან მთელ ფაილს მეხსიერებაში (სტრიქონის ან სტრიქონების სახით) — არაეფექტურია დიდი ფაილებისთვის.
იტერაცია ფაილზე ან readline() კითხულობს ხაზ-ხაზზე და ინახავს მეხსიერებაში მხოლოდ თანმიმდევრულად საჭირო ნაწილს — საუკეთესო პრაქტიკა დიდ მონაცემებთან.

საწყისი სავარჯიშოები¶

### 1. შექმენი ტექსტური ფაილი და ჩაწერე შენი სახელი
with open("name.txt", "w") as f:
    f.write("ჩემი სახელი")

### 2. წაიკითხე ფაილის შიგთავსი და დაბეჭდე
with open("name.txt", "r") as f:
    print(f.read())

### 3. ჩაწერე 3 სტრიქონი და პროგრამაში ცალ–ცალკე დაბეჭდე
with open("lines.txt", "w") as f:
    f.write("ხაზი 1\nხაზი 2\nხაზი 3\n")

with open("lines.txt", "r") as f:
    for line in f:
        print(line.strip())

### 4. დაითვალე ფაილის სტრიქონების რაოდენობა
with open("lines.txt", "r") as f:
    count = len(f.readlines())

print(count)

### 5. დაითვალე ფაილში სიმბოლოების რაოდენობა
with open("lines.txt", "r") as f:
    text = f.read()

print(len(text))

### 6. დაამატე ტექსტი ისე, რომ არსებული არ წაიშალოს
with open("lines.txt", "a") as f:
    f.write("ახალი ხაზი\n")

### 7. ჩაწერე list ფაილში writelines()–ით
data = ["One\n", "Two\n", "Three\n"]

with open("list.txt", "w") as f:
    f.writelines(data)

### 8. დაბეჭდე მხოლოდ სტრიქონები, რომლებიც შეიცავს სიტყვას „Python“
with open("list.txt", "r") as f:
    for line in f:
        if "Python" in line:
            print(line.strip())

### 9. შეამოწმე ფაილის არსებობა და შემდეგ წაიკითხე
import os

if os.path.exists("list.txt"):
    with open("list.txt") as f:
        print(f.read())
else:
    print("ფაილი არ არსებობს")

### 10. წაიკითხე მხოლოდ პირველი 5 სიმბოლო
with open("list.txt") as f:
    print(f.read(5))

### 11. ჩაწერე რიცხვების სია ფაილში და გამოთვალე ჯამი
nums = [1,2,3,4,5]

with open("nums.txt","w") as f:
    for n in nums:
        f.write(str(n)+"\n")

with open("nums.txt") as f:
    total = sum(int(line) for line in f)

print(total)

### 12. ჩაწერე 10 რიცხვი და იპოვე მაქსიმუმი
numbers = [3,7,1,9,5,12,4,8,6,2]

with open("numbers.txt","w") as f:
    for n in numbers:
        f.write(str(n)+"\n")

with open("numbers.txt") as f:
    mx = max(int(line) for line in f)

print(mx)

### 13. ორი ფაილის გაერთიანება მესამეში
with open("a.txt") as f1, open("b.txt") as f2:
    with open("merged.txt","w") as out:
        out.write(f1.read())
        out.write(f2.read())

### 14. ფაილის კოპირება shutil.copy()
import shutil
shutil.copy("a.txt", "a_copy.txt")

### 15. შეცვალე სიტყვა “cat” → “dog”
with open("pets.txt") as f:
    text = f.read()

text = text.replace("cat","dog")

with open("pets.txt","w") as f:
    f.write(text)

### 16. CSV – დაბეჭდე მხოლოდ ასაკი
with open("data.csv") as f:
    for line in f:
        name, age = line.strip().split(",")
        print(age)

### 17. CSV – დაამატე ახალი მწკრივი
with open("data.csv","a") as f:
    f.write("Giorgi,25\n")

### 18. JSON – შეცვალე ერთ-ერთი value
import json

with open("info.json") as f:
    data = json.load(f)

data["age"] = 30

with open("info.json","w") as f:
    json.dump(data, f, indent=4)

### 19. ჩაწერე ფაილში 100 შემთხვევითი რიცხვი
import random

with open("rand.txt","w") as f:
    for _ in range(100):
        f.write(str(random.randint(1,1000))+"\n")

### 20. წაიკითხე ეს რიცხვები და დახარისხებული გამოტანე
with open("rand.txt") as f:
    numbers = [int(x) for x in f]

for n in sorted(numbers):
    print(n)

# საწყისი ნაწილი I — საბაზისო ოპერაციები
### 1. homework.txt – ჩაწერე სახელი
with open("homework.txt","w") as f:
    f.write("სახელი")

### 2. წაიკითხოს და დაბეჭდოს
with open("homework.txt") as f:
    print(f.read())

### 3. დაამატოს გვარი
with open("homework.txt","a") as f:
    f.write("\ნგვარი")

### 4. 5 სტრიქონი writelines()–ით
lines = ["a\n","b\n","c\n","d\n","e\n"]

with open("list_data.txt","w") as f:
    f.writelines(lines)

### 5. readline() 3-ჯერ
with open("list_data.txt") as f:
    print(f.readline().strip())
    print(f.readline().strip())
    print(f.readline().strip())

### 6. readlines() და strip()
with open("list_data.txt") as f:
    lines = [line.strip() for line in f.readlines()]

print(lines)

### 7. numbers.txt – ჩაწერე 1–10
with open("numbers.txt","w") as f:
    for i in range(1,11):
        f.write(str(i)+"\n")

### 8. დაბეჭდე მხოლოდ ლუწი
with open("numbers.txt") as f:
    for line in f:
        n = int(line)
        if n % 2 == 0:
            print(n)

### 9. safe_write()
def safe_write(filename, content):
    with open(filename,"w") as f:
        f.write(content)

### 10. read_and_print() – FileNotFoundError
def read_and_print(filename):
    try:
        with open(filename) as f:
            print(f.read())
    except FileNotFoundError:
        print("ფაილი ვერ მოიძებნა")

# კითხვა/ჩაწერა, დამუშავება
### 11. scores.txt — 5 ჩანაწერი
data = ["Ana,80\n","Luka,60\n","Nika,75\n","Mari,95\n","Giorgi,85\n"]

with open("scores.txt","w") as f:
    f.writelines(data)

### 12. საშუალო ქულა
with open("scores.txt") as f:
    scores = [int(line.split(",")[1]) for line in f]

avg = sum(scores) / len(scores)
print(avg)

### 13. ჩაწერე მხოლოდ ქულა > 70
with open("scores.txt") as f, open("passed.txt","w") as out:
    for line in f:
        name, score = line.split(",")
        if int(score) > 70:
            out.write(line)

### 14. log.txt – მიმდინარე დრო
import datetime

with open("log.txt","a") as f:
    f.write(str(datetime.datetime.now())+"\n")

### 15. replace_text()
def replace_text(filename, old, new):
    with open(filename) as f:
        data = f.read()
    data = data.replace(old, new)
    with open(filename,"w") as f:
        f.write(data)

### 16. settings.ini → dict
with open("settings.ini","w") as f:
    f.write("username=admin\nmax_attempts=5")

config = {}
with open("settings.ini") as f:
    for line in f:
        key, val = line.strip().split("=")
        config[key] = val

### 17. ჩაწერა user_input.txt – სანამ “დასრულება”
with open("user_input.txt","w") as f:
    while True:
        text = input("→ ")
        if text == "დასრულება":
            break
        f.write(text + "\n")

### 18. user_input.txt – დათვალე ხაზები
with open("user_input.txt") as f:
    print(len(f.readlines()))

### 19. შექმნა empty.txt
open("empty.txt","w").close()

### 20. შეამოწმე f.read() == ''
with open("empty.txt") as f:
    print(f.read() == "")

# ფაილური სისტემის მანიპულაცია — os, shutil
### 21. შექმნა temp_files
import os
os.mkdir("temp_files")

### 22. temp_files/draft.txt
with open("temp_files/draft.txt","w") as f:
    f.write("Draft")

### 23. გადარქვა draft → final
os.rename("temp_files/draft.txt","temp_files/final.txt")

### 24. ფაილის არსებობა
import os
print(os.path.exists("temp_files/final.txt"))

### 25. კოპირება backup.txt
import shutil
shutil.copy("temp_files/final.txt","temp_files/backup.txt")

### 26. გადატანა backup.txt უკან
shutil.move("temp_files/backup.txt","backup.txt")

### 27. წაშლა backup.txt
os.remove("backup.txt")

### 28. წაშლა temp_files/final.txt
os.remove("temp_files/final.txt")

### 29. წაშლა დირექტორია temp_files
os.rmdir("temp_files")

### 30. safe_delete(path)
def safe_delete(path):
    import os
    try:
        os.remove(path)
    except FileNotFoundError:
        print("ფაილი არ არსებობს")

### 31. შექმნას logs და file_1.txt–file_10.txt
os.makedirs("logs", exist_ok=True)

for i in range(1,11):
    with open(f"logs/file_{i}.txt","w") as f:
        f.write("log")

### 32. წაშალოს logs დირექტორია მთლიანად
shutil.rmtree("logs")

📚 Python: მუშაობა ფაილებთან (File I/O)¶

1. საბაზისო ოპერაციები ფაილებთან¶

1.1. ფაილის გახსნა და დახურვა: open() და close()¶

მაგალითი 1: ფაილის გახსნა და დახურვა¶

1.2. უსაფრთხო მუშაობა: with ოპერატორი¶

მაგალითი 2: with გამოყენება¶