# راه حل:
# نوشتن در فایل
with open("greeting.txt", "w", encoding="utf-8") as f:
    f.write("سلام، دنیای پایتون!")

# خواندن از فایل
with open("greeting.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# راه حل:
with open("log.txt", "a", encoding="utf-8") as f:
    f.write("2024-01-01: Start\n")

with open("log.txt", "a", encoding="utf-8") as f:
    f.write("2024-01-02: Processing\n")

# خواندن برای نمایش
with open("log.txt", "r", encoding="utf-8") as f:
    print(f.read())

# راه حل:
# ایجاد فایل نمونه
with open("lines.txt", "w", encoding="utf-8") as f:
    f.write("اولین خط\nدومین خط\nسومین خط\n")

# خواندن خط به خط
with open("lines.txt", "r", encoding="utf-8") as f:
    for i, line in enumerate(f, 1):
        print(f"خط {i}: {line.strip()}")

# راه حل:
import os

filename = "test.txt"

if os.path.exists(filename):
    with open(filename, "r", encoding="utf-8") as f:
        print(f.read())
else:
    print(f"فایل {filename} وجود ندارد")
    # ایجاد فایل جدید
    with open(filename, "w", encoding="utf-8") as f:
        f.write("فایل جدید ایجاد شد")

# راه حل:
# ایجاد فایل نمونه
with open("sample.txt", "w", encoding="utf-8") as f:
    f.write("این یک متن نمونه است.\nبرای تست شمارش.\nخط سوم.")

# شمارش
with open("sample.txt", "r", encoding="utf-8") as f:
    content = f.read()
    lines = content.split('\n')
    words = content.split()
    chars = len(content)
    
    print(f"خطوط: {len(lines)}")
    print(f"کلمات: {len(words)}")
    print(f"کاراکترها: {chars}")

# راه حل:
# ایجاد فایل مبدا
with open("source.txt", "w", encoding="utf-8") as f:
    f.write("این متن برای کپی است.")

# کپی کردن
with open("source.txt", "r", encoding="utf-8") as source:
    with open("destination.txt", "w", encoding="utf-8") as dest:
        dest.write(source.read())

# تأیید
with open("destination.txt", "r", encoding="utf-8") as f:
    print(f.read())

# راه حل 1: دستی
students = [("علی", 18), ("سارا", 20), ("رضا", 17)]

with open("students.csv", "w", encoding="utf-8") as f:
    f.write("نام,نمره\n")
    for name, score in students:
        f.write(f"{name},{score}\n")

# راه حل 2: با ماژول csv
import csv

with open("students.csv", "w", encoding="utf-8", newline='') as f:
    writer = csv.writer(f)
    writer.writerow(["نام", "نمره"])
    writer.writerows(students)

# راه حل:
import csv

students = []
with open("students.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # رد کردن سطر عنوان
    for row in reader:
        students.append((row[0], int(row[1])))

print(students)

# محاسبه میانگین نمرات
average = sum(score for _, score in students) / len(students)
print(f"میانگین نمرات: {average:.2f}")

# راه حل:
import json

user = {"name": "علی", "age": 25, "city": "تهران", "skills": ["Python", "SQL"]}

# نوشتن JSON
with open("user.json", "w", encoding="utf-8") as f:
    json.dump(user, f, ensure_ascii=False, indent=2)

# خواندن JSON
with open("user.json", "r", encoding="utf-8") as f:
    loaded_user = json.load(f)
    print(loaded_user)

# راه حل:
import json

products = [
    {"id": 1, "name": "لپتاپ", "price": 15000000},
    {"id": 2, "name": "موبایل", "price": 8000000},
    {"id": 3, "name": "تبلت", "price": 5000000}
]

# ذخیره
with open("products.json", "w", encoding="utf-8") as f:
    json.dump(products, f, ensure_ascii=False, indent=2)

# بارگذاری و جست‌وجو
with open("products.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)
    expensive = [p for p in loaded if p["price"] > 10000000]
    print("محصولات گران:", expensive)

# راه حل:
import json
import os

CONFIG_FILE = "config.json"

def load_config():
    if os.path.exists(CONFIG_FILE):
        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
            return json.load(f)
    return {"theme": "light", "lang": "fa", "notifications": True}

def save_config(config):
    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
        json.dump(config, f, ensure_ascii=False, indent=2)

def update_config(key, value):
    config = load_config()
    config[key] = value
    save_config(config)

# استفاده
config = load_config()
print("تنظیمات فعلی:", config)
update_config("theme", "dark")
print("تنظیمات جدید:", load_config())

# راه حل:
# ایجاد فایل نمونه
with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("Python یک زبان قدرتمند است.\n")
    f.write("یادگیری برنامه‌نویسی مهم است.\n")
    f.write("Python برای AI مناسب است.\n")

# جست‌وجو
search_word = "Python"
with open("notes.txt", "r", encoding="utf-8") as f:
    for i, line in enumerate(f, 1):
        if search_word in line:
            print(f"خط {i}: {line.strip()}")

# جست‌وجوی case-insensitive
with open("notes.txt", "r", encoding="utf-8") as f:
    matches = [line.strip() for line in f if search_word.lower() in line.lower()]
    print(f"\nتعداد نتایج: {len(matches)}")

# راه حل:
import sqlite3

# اتصال و ایجاد جدول
conn = sqlite3.connect('library.db')
cursor = conn.cursor()

cursor.execute('''
    CREATE TABLE IF NOT EXISTS books (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        author TEXT NOT NULL,
        year INTEGER
    )
''')

# اضافه کردن کتاب‌ها
books = [
    ("گاتسبی بزرگ", "اسکات فیتزجرالد", 1925),
    ("1984", "جورج اورول", 1949),
    ("کشتن مرغ مقلد", "هارپر لی", 1960)
]

cursor.executemany('INSERT INTO books (title, author, year) VALUES (?, ?, ?)', books)
conn.commit()

# جست‌وجو
cursor.execute('SELECT * FROM books WHERE year > 1940')
for row in cursor.fetchall():
    print(row)

conn.close()

# راه حل:
import sqlite3

class UserDB:
    def __init__(self, db_name='users.db'):
        self.conn = sqlite3.connect(db_name)
        self.cursor = self.conn.cursor()
        self.create_table()
    
    def create_table(self):
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                username TEXT UNIQUE NOT NULL,
                email TEXT,
                age INTEGER
            )
        ''')
        self.conn.commit()
    
    def create_user(self, username, email, age):
        self.cursor.execute('INSERT INTO users (username, email, age) VALUES (?, ?, ?)',
                           (username, email, age))
        self.conn.commit()
    
    def read_users(self):
        self.cursor.execute('SELECT * FROM users')
        return self.cursor.fetchall()
    
    def update_user(self, user_id, email=None, age=None):
        if email:
            self.cursor.execute('UPDATE users SET email = ? WHERE id = ?', (email, user_id))
        if age:
            self.cursor.execute('UPDATE users SET age = ? WHERE id = ?', (age, user_id))
        self.conn.commit()
    
    def delete_user(self, user_id):
        self.cursor.execute('DELETE FROM users WHERE id = ?', (user_id,))
        self.conn.commit()

# استفاده
db = UserDB()
db.create_user("ali123", "ali@example.com", 25)
db.create_user("sara456", "sara@example.com", 22)
print("همه کاربران:", db.read_users())
db.update_user(1, age=26)
print("بعد از آپدیت:", db.read_users())

# راه حل:
import shutil
from datetime import datetime

def backup_file(source_file):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_name = f"backup_{timestamp}_{source_file}"
    
    shutil.copy2(source_file, backup_name)
    print(f"بکاپ ایجاد شد: {backup_name}")
    return backup_name

# ایجاد فایل نمونه
with open("important.txt", "w", encoding="utf-8") as f:
    f.write("داده‌های مهم")

# بکاپ گیری
backup_file("important.txt")

# بکاپ چندین فایل
import os

def backup_directory(directory, backup_dir="backups"):
    os.makedirs(backup_dir, exist_ok=True)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    
    for filename in os.listdir(directory):
        if filename.endswith('.txt'):
            source = os.path.join(directory, filename)
            dest = os.path.join(backup_dir, f"{timestamp}_{filename}")
            shutil.copy2(source, dest)
            print(f"بکاپ شد: {filename}")

# راه حل:
from datetime import datetime

class Logger:
    def __init__(self, log_file='app.log'):
        self.log_file = log_file
    
    def _write_log(self, level, message):
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        log_entry = f"[{timestamp}] {level}: {message}\n"
        
        with open(self.log_file, 'a', encoding='utf-8') as f:
            f.write(log_entry)
        print(log_entry.strip())
    
    def info(self, message):
        self._write_log('INFO', message)
    
    def warning(self, message):
        self._write_log('WARNING', message)
    
    def error(self, message):
        self._write_log('ERROR', message)

# استفاده
logger = Logger()
logger.info('برنامه شروع شد')
logger.warning('حافظه کم است')
logger.error('خطا در اتصال به پایگاه داده')

# خواندن لاگ‌ها
with open('app.log', 'r', encoding='utf-8') as f:
    print("\n--- محتوای لاگ ---")
    print(f.read())

# راه حل:
import csv
import json

# ایجاد CSV نمونه
with open('products.csv', 'w', encoding='utf-8', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['id', 'name', 'price', 'stock'])
    writer.writerow([1, 'لپتاپ', 15000000, 5])
    writer.writerow([2, 'موبایل', 8000000, 10])
    writer.writerow([3, 'تبلت', 5000000, 8])

# تبدیل CSV به JSON
products = []
with open('products.csv', 'r', encoding='utf-8') as f:
    reader = csv.DictReader(f)
    for row in reader:
        # تبدیل نوع داده‌ها
        row['id'] = int(row['id'])
        row['price'] = int(row['price'])
        row['stock'] = int(row['stock'])
        products.append(row)

# ذخیره JSON
with open('products.json', 'w', encoding='utf-8') as f:
    json.dump(products, f, ensure_ascii=False, indent=2)

print("تبدیل انجام شد!")
print(json.dumps(products, ensure_ascii=False, indent=2))

# راه حل:
import tempfile
import os

# فایل موقت که خودکار حذف می‌شود
with tempfile.NamedTemporaryFile(mode='w+', delete=True, encoding='utf-8') as temp:
    # نوشتن داده
    temp.write("داده‌های موقت برای پردازش\n")
    temp.write("این فایل بعد از بسته شدن حذف می‌شود\n")
    
    # بازگشت به ابتدا برای خواندن
    temp.seek(0)
    print("محتوای فایل موقت:")
    print(temp.read())
    
    print(f"مسیر فایل موقت: {temp.name}")

print("فایل موقت حذف شد")

# دایرکتوری موقت
with tempfile.TemporaryDirectory() as tmpdir:
    print(f"دایرکتوری موقت: {tmpdir}")
    
    # ایجاد فایل در دایرکتوری موقت
    temp_file = os.path.join(tmpdir, 'data.txt')
    with open(temp_file, 'w') as f:
        f.write("داده موقت")
    
    print(f"فایل ایجاد شد: {temp_file}")

print("دایرکتوری و محتویاتش حذف شدند")

# راه حل:
import json
import time
import os

CACHE_FILE = 'cache.json'

def load_cache():
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE, 'r') as f:
            return json.load(f)
    return {}

def save_cache(cache):
    with open(CACHE_FILE, 'w') as f:
        json.dump(cache, f, indent=2)

def expensive_calculation(n):
    """محاسبه سنگین (شبیه‌سازی با sleep)"""
    print(f"در حال محاسبه برای {n}...")
    time.sleep(2)  # شبیه‌سازی تاخیر
    return n ** 2

def cached_calculation(n):
    cache = load_cache()
    key = str(n)
    
    if key in cache:
        print(f"نتیجه از کش برگردانده شد: {n}")
        return cache[key]
    
    result = expensive_calculation(n)
    cache[key] = result
    save_cache(cache)
    return result

# تست
print("اولین بار (محاسبه واقعی):")
result1 = cached_calculation(10)
print(f"نتیجه: {result1}\n")

print("بار دوم (از کش):")
result2 = cached_calculation(10)
print(f"نتیجه: {result2}")

# راه حل:
import sqlite3
import json
from datetime import datetime

class NotesApp:
    def __init__(self, db_name='notes.db'):
        self.conn = sqlite3.connect(db_name)
        self.cursor = self.conn.cursor()
        self.create_table()
    
    def create_table(self):
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS notes (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                title TEXT NOT NULL,
                content TEXT,
                created_at TEXT,
                tags TEXT
            )
        ''')
        self.conn.commit()
    
    def add_note(self, title, content, tags=None):
        created_at = datetime.now().isoformat()
        tags_str = ','.join(tags) if tags else ''
        self.cursor.execute(
            'INSERT INTO notes (title, content, created_at, tags) VALUES (?, ?, ?, ?)',
            (title, content, created_at, tags_str)
        )
        self.conn.commit()
        return self.cursor.lastrowid
    
    def get_all_notes(self):
        self.cursor.execute('SELECT * FROM notes ORDER BY created_at DESC')
        return self.cursor.fetchall()
    
    def search_notes(self, keyword):
        self.cursor.execute(
            'SELECT * FROM notes WHERE title LIKE ? OR content LIKE ?',
            (f'%{keyword}%', f'%{keyword}%')
        )
        return self.cursor.fetchall()
    
    def export_to_json(self, filename='notes_export.json'):
        notes = self.get_all_notes()
        notes_list = [
            {
                'id': n[0], 'title': n[1], 'content': n[2],
                'created_at': n[3], 'tags': n[4].split(',') if n[4] else []
            }
            for n in notes
        ]
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(notes_list, f, ensure_ascii=False, indent=2)
        print(f"Export شد به {filename}")
    
    def import_from_json(self, filename):
        with open(filename, 'r', encoding='utf-8') as f:
            notes = json.load(f)
        for note in notes:
            self.add_note(note['title'], note['content'], note.get('tags'))
        print(f"{len(notes)} یادداشت import شد")

# استفاده
app = NotesApp()
app.add_note("یادآوری", "فردا جلسه مهم دارم", ['کار', 'مهم'])
app.add_note("آموزش Python", "تمرین فایل‌ها را انجام بده", ['آموزش'])
app.add_note("خرید", "نان، شیر، تخم‌مرغ", ['شخصی'])

print("همه یادداشت‌ها:")
for note in app.get_all_notes():
    print(f"- {note[1]}: {note[2]}")

print("\nجست‌وجو 'Python':")
for note in app.search_notes('Python'):
    print(f"- {note[1]}")

app.export_to_json()