النسخ السطحية والعميقة: كيفية نسخ البيانات المعقدة بشكل صحيح في Python

# النسخ البسيط (Reference Copy) - خطر!
original = [1, 2, 3]
copy = original

print(f"id(original): {id(original)}")
print(f"id(copy): {id(copy)}")
print(f"هل هما نفس الكائن؟ {original is copy}")  # True!

# تعديل copy يؤثر على original
copy.append(4)
print(f"original: {original}")  # [1, 2, 3, 4] (تغيرت!)

# Shallow Copy مع قائمة بسيطة
original = [1, 2, 3]
shallow = original.copy()  # أو list(original)

print(f"id(original): {id(original)}")
print(f"id(shallow): {id(shallow)}")
print(f"هل هما نفس الكائن؟ {original is shallow}")  # False

# تعديل shallow لا يؤثر على original
shallow.append(4)
print(f"original: {original}")  # [1, 2, 3]
print(f"shallow: {shallow}")    # [1, 2, 3, 4]

# Shallow Copy مع قائمة متعددة الأبعاد
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

shallow = matrix.copy()

print(f"matrix is shallow: {matrix is shallow}")        # False (الحاويات مختلفة)
print(f"matrix[0] is shallow[0]: {matrix[0] is shallow[0]}")  # True! (نفس الداخل)

# تعديل العنصر الداخلي
shallow[0][0] = 999

print(f"matrix: {matrix}")    # [[999, 2, 3], [4, 5, 6], [7, 8, 9]] (تغيرت!)
print(f"shallow: {shallow}")  # [[999, 2, 3], [4, 5, 6], [7, 8, 9]]

# Shallow Copy مع dictionary يحتوي على قوائم
person = {
    "name": "أحمد",
    "grades": [90, 85, 88]
}

person_copy = person.copy()

# تعديل القيمة الأساسية (string) - آمن
person_copy["name"] = "محمد"
print(f"person['name']: {person['name']}")  # أحمد (لم تتغير)

# تعديل قائمة داخل dictionary - خطر!
person_copy["grades"].append(95)
print(f"person['grades']: {person['grades']}")  # [90, 85, 88, 95] (تغيرت!)

from copy import deepcopy

# Deep Copy مع قائمة متعددة الأبعاد
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

deep = deepcopy(matrix)

# تعديل العنصر الداخلي
deep[0][0] = 999

print(f"matrix: {matrix}")    # [[1, 2, 3], [4, 5, 6], [7, 8, 9]] (لم تتغير!)
print(f"deep: {deep}")        # [[999, 2, 3], [4, 5, 6], [7, 8, 9]]

from copy import deepcopy

# Dictionary معقد
student = {
    "name": "أحمد",
    "age": 20,
    "grades": [90, 85, 88],
    "courses": {
        "math": {"score": 92, "teacher": "محمد"},
        "science": {"score": 88, "teacher": "فاطمة"}
    }
}

# Deep Copy
student_copy = deepcopy(student)

# تعديل البيانات المتعددة المستويات
student_copy["name"] = "علي"
student_copy["grades"].append(95)
student_copy["courses"]["math"]["score"] = 100

print("البيانات الأصلية:")
print(f"الاسم: {student['name']}")  # أحمد
print(f"الدرجات: {student['grades']}")  # [90, 85, 88]
print(f"درجة الرياضيات: {student['courses']['math']['score']}")  # 92

print("\nالنسخة المعدلة:")
print(f"الاسم: {student_copy['name']}")  # علي
print(f"الدرجات: {student_copy['grades']}")  # [90, 85, 88, 95]
print(f"درجة الرياضيات: {student_copy['courses']['math']['score']}")  # 100

from copy import deepcopy

# قائمة متعددة الأبعاد جداً
data = [
    [1, 2, [3, 4, 5]],
    [6, 7, [8, 9, 10]],
    [11, 12, [13, 14, 15]]
]

deep = deepcopy(data)

# تعديل العناصر المتعمقة
deep[0][2][0] = 999
deep[1][2].append(100)

print("البيانات الأصلية:")
print(data)

print("\nالنسخة المعدلة:")
print(deep)

# List
list1 = [1, 2, 3]
list2 = list1.copy()

# Dictionary
dict1 = {"a": 1, "b": 2}
dict2 = dict1.copy()

# List
list1 = [1, 2, 3]
list2 = list(list1)

# Dictionary
dict1 = {"a": 1, "b": 2}
dict2 = dict(dict1)

# List
list1 = [1, 2, 3]
list2 = list1[:]  # Slicing يعمل كـ Shallow Copy

from copy import copy

list1 = [1, 2, 3]
list2 = copy(list1)

dict1 = {"a": 1, "b": 2}
dict2 = copy(dict1)

from copy import deepcopy

# قائمة الطلاب الأصلية
original_students = [
    {"id": 1, "name": "أحمد", "grades": [90, 85, 88]},
    {"id": 2, "name": "فاطمة", "grades": [92, 89, 91]},
    {"id": 3, "name": "محمد", "grades": [88, 87, 90]}
]

# إنشاء نسخة لتعديلها (الحل الخاطئ)
students_wrong = original_students.copy()
students_wrong[0]["grades"].append(100)

# النتيجة: تأثرت البيانات الأصلية!
print("الحل الخاطئ - تأثرت البيانات الأصلية:")
print(f"original_students[0]['grades']: {original_students[0]['grades']}")
# النتيجة: [90, 85, 88, 100]

# الحل الصحيح
original_students = [
    {"id": 1, "name": "أحمد", "grades": [90, 85, 88]},
    {"id": 2, "name": "فاطمة", "grades": [92, 89, 91]},
    {"id": 3, "name": "محمد", "grades": [88, 87, 90]}
]

students_correct = deepcopy(original_students)
students_correct[0]["grades"].append(100)

print("\nالحل الصحيح - البيانات الأصلية آمنة:")
print(f"original_students[0]['grades']: {original_students[0]['grades']}")
# النتيجة: [90, 85, 88]
print(f"students_correct[0]['grades']: {students_correct[0]['grades']}")
# النتيجة: [90, 85, 88, 100]

from copy import deepcopy

# قائمة أصلية
products = [
    {"name": "كتاب", "price": 50, "quantity": 10},
    {"name": "قلم", "price": 5, "quantity": 20},
    {"name": "دفتر", "price": 15, "quantity": 15}
]

# نسخة عميقة للعمل عليها
products_backup = deepcopy(products)

# تطبيق خصم على الأسعار
for product in products_backup:
    product["price"] = product["price"] * 0.9  # خصم 10%

print("الأسعار الأصلية:")
for p in products:
    print(f"{p['name']}: {p['price']}")

print("\nالأسعار بعد الخصم:")
for p in products_backup:
    print(f"{p['name']}: {p['price']}")

from copy import deepcopy

# إعدادات التطبيق (dictionary معقد)
config = {
    "database": {
        "host": "localhost",
        "port": 5432,
        "credentials": ["admin", "password123"]
    },
    "api": {
        "endpoints": ["users", "products", "orders"],
        "timeout": 30
    }
}

# محاولة نسخ الإعدادات (الحل الخاطئ)
config_dev = config.copy()
config_dev["database"]["host"] = "dev-server"
config_dev["database"]["credentials"][0] = "dev_admin"

print("الإعدادات الأصلية (تأثرت!):")
print(f"Host: {config['database']['host']}")
print(f"User: {config['database']['credentials'][0]}")

# الحل الصحيح
config = {
    "database": {
        "host": "localhost",
        "port": 5432,
        "credentials": ["admin", "password123"]
    },
    "api": {
        "endpoints": ["users", "products", "orders"],
        "timeout": 30
    }
}

config_dev = deepcopy(config)
config_dev["database"]["host"] = "dev-server"
config_dev["database"]["credentials"][0] = "dev_admin"

print("\nالإعدادات الأصلية (آمنة الآن):")
print(f"Host: {config['database']['host']}")
print(f"User: {config['database']['credentials'][0]}")

print("\nإعدادات التطوير:")
print(f"Host: {config_dev['database']['host']}")
print(f"User: {config_dev['database']['credentials'][0]}")

# الخطأ: استخدام Shallow Copy مع بيانات متعددة المستويات
teams = [
    {"name": "فريق أ", "members": ["أحمد", "فاطمة"]},
    {"name": "فريق ب", "members": ["محمد", "علي"]}
]

teams_copy = teams.copy()  # Shallow Copy - غير كافي!
teams_copy[0]["members"].append("سارة")

# المشكلة:
print(teams[0]["members"])  # ['أحمد', 'فاطمة', 'سارة'] (تغيرت!)

# الحل:
from copy import deepcopy
teams_copy = deepcopy(teams)  # Deep Copy - الحل الصحيح
teams_copy[0]["members"].append("سارة")

print(teams[0]["members"])  # ['أحمد', 'فاطمة'] (آمن!)

# الخطأ الشائع: عدم التمييز بين النسخ
data = [1, 2, 3]

# Reference copy (خطر!)
ref = data

# Shallow copy (أفضل قليلاً)
shallow = data.copy()

# Deep copy (الأفضل للبيانات المعقدة)
from copy import deepcopy
deep = deepcopy(data)

# القاعدة:
# - استخدم .copy() للبيانات البسيطة
# - استخدم deepcopy() للبيانات المعقدة
# - تجنب reference copy (=) إلا إذا كنت تريد ذلك بقصد

# الخطأ
# deep = deepcopy(data)  # NameError: name 'deepcopy' is not defined

# الحل
from copy import deepcopy

data = [[1, 2, 3], [4, 5, 6]]
deep = deepcopy(data)  # الآن يعمل بشكل صحيح

# طريقة بسيطة: استخدام list comprehension
original = [1, 2, 3, 4, 5]
copy = [x for x in original]  # نسخة مستقلة

copy.append(6)
print(f"original: {original}")  # [1, 2, 3, 4, 5]
print(f"copy: {copy}")          # [1, 2, 3, 4, 5, 6]

from copy import deepcopy

class ResourceManager:
    def __init__(self):
        self.resources = {
            "servers": [
                {"name": "server1", "cpu": 4, "memory": 8},
                {"name": "server2", "cpu": 8, "memory": 16}
            ],
            "storage": [
                {"name": "storage1", "capacity": 1000}
            ]
        }
    
    def create_backup(self):
        """إنشاء نسخة احتياطية كاملة"""
        return deepcopy(self.resources)
    
    def get_snapshot(self):
        """الحصول على لقطة سريعة (shallow copy)"""
        return self.resources.copy()
    
    def modify_resource(self, resource_type, index, key, value):
        """تعديل موقع معين"""
        if resource_type in self.resources:
            if index < len(self.resources[resource_type]):
                self.resources[resource_type][index][key] = value
                return True
        return False
    
    def test_modification(self):
        """اختبار التعديلات بدون التأثير على الأصلية"""
        backup = self.create_backup()
        backup["servers"][0]["cpu"] = 16
        
        # المقارنة
        print("الموارد الأصلية:")
        print(f"CPU للخادم الأول: {self.resources['servers'][0]['cpu']}")
        
        print("\nالنسخة الاحتياطية (معدلة):")
        print(f"CPU للخادم الأول: {backup['servers'][0]['cpu']}")

# الاستخدام
manager = ResourceManager()
manager.test_modification()