.png "AI بالعربي"){kind=logo}
🔢 الدرس الثاني: NumPy للحوسبة العلمية
📖 الدرس الثاني
⏱️ 60-75 دقيقة
🎓 متوسط
💻 15+ مثال عملي
2
NumPy: أساس الحوسبة العلمية في Python
🔢 الدرس الثاني: NumPy للحوسبة العلمية
🎯 أهداف الدرس
- فهم ما هو NumPy ولماذا هو أساسي للذكاء الاصطناعي
- إتقان إنشاء والتعامل مع المصفوفات متعددة الأبعاد
- تعلم العمليات الرياضية والإحصائية المتقدمة
- فهم الفرق في الأداء بين NumPy وPython العادي
- تطبيق NumPy في مشاكل الذكاء الاصطناعي الحقيقية
- إتقان الفهرسة والتقطيع المتقدم
📋 المتطلبات السابقة
- إكمال الدرس الأول: إعداد بيئة Python وفهم الأساسيات
- معرفة بالقوائم في Python: إنشاء وتعديل القوائم
- مفاهيم رياضية: الجبر الأساسي والمصفوفات
- NumPy مثبت: pip install numpy
🤔 ما هو NumPy ولماذا هو مهم؟
NumPy (Numerical Python) هو المكتبة الأساسية للحوسبة العلمية في Python. إنه الأساس الذي تبنى عليه جميع مكتبات الذكاء الاصطناعي والتعلم الآلي.
الاستخدامات المتنوعة لـ NumPy في الحوسبة العلمية
📊 حقائق مذهلة عن NumPy:
- السرعة: أسرع بـ 50-100 مرة من Python العادي
- الذاكرة: يستخدم ذاكرة أقل بـ 20 مرة من القوائم العادية
- الشعبية: يستخدمه 95% من علماء البيانات
- الأساس: Pandas وScikit-learn وTensorFlow مبنية عليه
- اللغة: مكتوب بـ C للحصول على أقصى سرعة
⚡ لماذا NumPy سريع جداً؟
🔍 مقارنة الأداء: Python العادي مقابل NumPy
دعنا نرى الفرق الحقيقي في الأداء:
مثال: جمع مليون رقم
import time
import numpy as np
# إنشاء مليون رقم
numbers_list = list(range(1000000)) # قائمة Python عادية
numbers_array = np.array(numbers_list) # مصفوفة NumPy
print(f"حجم القائمة العادية: {len(numbers_list):,} عنصر")
print(f"حجم مصفوفة NumPy: {numbers_array.size:,} عنصر")
# قياس وقت الجمع باستخدام Python العادي
start_time = time.time()
python_sum = sum(numbers_list)
python_time = time.time() - start_time
# قياس وقت الجمع باستخدام NumPy
start_time = time.time()
numpy_sum = np.sum(numbers_array)
numpy_time = time.time() - start_time
print(f"
النتائج:")
print(f"Python العادي: {python_sum:,} في {python_time:.4f} ثانية")
print(f"NumPy: {numpy_sum:,} في {numpy_time:.4f} ثانية")
print(f"NumPy أسرع بـ {python_time/numpy_time:.1f} مرة! 🚀")
| الخاصية | Python العادي | NumPy | الفرق |
|---|---|---|---|
| السرعة | بطيء | سريع جداً | 50-100x أسرع |
| استهلاك الذاكرة | عالي | منخفض | 20x أقل |
| العمليات الرياضية | محدودة | شاملة | مئات الدوال |
| التوافق | Python فقط | C/C++/Fortran | متعدد اللغات |
🏗️ إنشاء المصفوفات (Arrays)
المصفوفة هي الوحدة الأساسية في NumPy. دعنا نتعلم كيفية إنشائها بطرق مختلفة:
الطريقة 1: من القوائم العادية
import numpy as np
# مصفوفة أحادية البعد (1D Array)
arr_1d = np.array([1, 2, 3, 4, 5])
print(f"مصفوفة 1D: {arr_1d}")
print(f"النوع: {type(arr_1d)}")
print(f"الشكل: {arr_1d.shape}")
print(f"عدد الأبعاد: {arr_1d.ndim}")
print(f"عدد العناصر: {arr_1d.size}")
# مصفوفة ثنائية البعد (2D Array)
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(f"
مصفوفة 2D:
{arr_2d}")
print(f"الشكل: {arr_2d.shape}") # (2, 3) = صفان و 3 أعمدة
print(f"عدد الأبعاد: {arr_2d.ndim}")
# مصفوفة ثلاثية البعد (3D Array)
arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(f"
مصفوفة 3D:
{arr_3d}")
print(f"الشكل: {arr_3d.shape}") # (2, 2, 2)
الطريقة 2: الدوال المدمجة
# مصفوفة من الأصفار
zeros = np.zeros((3, 4)) # 3 صفوف، 4 أعمدة
print(f"مصفوفة الأصفار:
{zeros}")
# مصفوفة من الآحاد
ones = np.ones((2, 3))
print(f"
مصفوفة الآحاد:
{ones}")
# مصفوفة بقيمة محددة
full = np.full((2, 2), 7) # مصفوفة 2x2 مملوءة بالرقم 7
print(f"
مصفوفة مملوءة بـ 7:
{full}")
# مصفوفة الهوية (Identity Matrix)
identity = np.eye(3) # مصفوفة 3x3
print(f"
مصفوفة الهوية:
{identity}")
# مصفوفة عشوائية
random = np.random.random((2, 3)) # أرقام عشوائية بين 0 و 1
print(f"
مصفوفة عشوائية:
{random}")
# تسلسل من الأرقام
sequence = np.arange(0, 10, 2) # من 0 إلى 10 بخطوة 2
print(f"
تسلسل: {sequence}")
# تقسيم متساوي
linspace = np.linspace(0, 1, 5) # 5 أرقام متساوية بين 0 و 1
print(f"تقسيم متساوي: {linspace}")
أنواع مختلفة من المصفوفات في NumPy
🎯 أنواع البيانات (Data Types)
NumPy يدعم أنواع بيانات متعددة لتحسين الأداء واستخدام الذاكرة:
أنواع البيانات الأساسية
# أعداد صحيحة
int_array = np.array([1, 2, 3], dtype=np.int32)
print(f"أعداد صحيحة: {int_array}, النوع: {int_array.dtype}")
# أعداد عشرية
float_array = np.array([1.1, 2.2, 3.3], dtype=np.float64)
print(f"أعداد عشرية: {float_array}, النوع: {float_array.dtype}")
# أعداد منطقية
bool_array = np.array([True, False, True], dtype=np.bool_)
print(f"أعداد منطقية: {bool_array}, النوع: {bool_array.dtype}")
# نصوص
string_array = np.array(['أ', 'ب', 'ج'], dtype='U1')
print(f"نصوص: {string_array}, النوع: {string_array.dtype}")
# تحويل نوع البيانات
original = np.array([1.7, 2.8, 3.9])
converted = original.astype(np.int32)
print(f"
الأصلي: {original}")
print(f"بعد التحويل: {converted}")
# معلومات عن استهلاك الذاكرة
print(f"
استهلاك الذاكرة:")
print(f"int32: {np.array([1], dtype=np.int32).itemsize} بايت لكل عنصر")
print(f"float64: {np.array([1.0], dtype=np.float64).itemsize} بايت لكل عنصر")
print(f"bool: {np.array([True], dtype=np.bool_).itemsize} بايت لكل عنصر")
🔍 الفهرسة والتقطيع (Indexing & Slicing)
الوصول للعناصر في NumPy أكثر قوة ومرونة من Python العادي:
الفهرسة الأساسية
# إنشاء مصفوفة للتجربة
arr = np.array([10, 20, 30, 40, 50])
print(f"المصفوفة: {arr}")
# الوصول للعناصر
print(f"العنصر الأول: {arr[0]}")
print(f"العنصر الأخير: {arr[-1]}")
print(f"العنصر الثالث: {arr[2]}")
# تعديل العناصر
arr[0] = 100
print(f"بعد التعديل: {arr}")
# التقطيع (Slicing)
print(f"
التقطيع:")
print(f"أول 3 عناصر: {arr[:3]}")
print(f"آخر 3 عناصر: {arr[-3:]}")
print(f"من الثاني للرابع: {arr[1:4]}")
print(f"كل عنصر ثاني: {arr[::2]}")
print(f"عكس المصفوفة: {arr[::-1]}")
الفهرسة المتقدمة للمصفوفات ثنائية البعد
# إنشاء مصفوفة 2D
matrix = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
print(f"المصفوفة:
{matrix}")
print(f"الشكل: {matrix.shape}")
# الوصول للعناصر
print(f"
الوصول للعناصر:")
print(f"العنصر في الصف 0، العمود 1: {matrix[0, 1]}")
print(f"العنصر في الصف 2، العمود 3: {matrix[2, 3]}")
# الوصول للصفوف والأعمدة
print(f"
الصف الأول: {matrix[0, :]}")
print(f"العمود الثاني: {matrix[:, 1]}")
print(f"آخر صف: {matrix[-1, :]}")
# التقطيع المتقدم
print(f"
التقطيع المتقدم:")
print(f"أول صفين، أول عمودين:
{matrix[:2, :2]}")
print(f"الصفوف 1-2، الأعمدة 2-3:
{matrix[1:3, 2:4]}")
# الفهرسة المنطقية
condition = matrix > 6
print(f"
العناصر الأكبر من 6: {matrix[condition]}")
# الفهرسة بالمصفوفات
rows = np.array([0, 2])
cols = np.array([1, 3])
print(f"عناصر محددة: {matrix[rows, cols]}")
التعامل مع المصفوفات في Python باستخدام NumPy
🧮 العمليات الرياضية
NumPy يوفر مجموعة شاملة من العمليات الرياضية المحسنة:
العمليات الأساسية
# إنشاء مصفوفتين للتجربة
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
print(f"المصفوفة a: {a}")
print(f"المصفوفة b: {b}")
# العمليات الأساسية (element-wise)
print(f"
العمليات الأساسية:")
print(f"الجمع: {a + b}")
print(f"الطرح: {a - b}")
print(f"الضرب: {a * b}")
print(f"القسمة: {a / b}")
print(f"القوة: {a ** 2}")
print(f"الجذر التربيعي: {np.sqrt(a)}")
# العمليات مع الأرقام المفردة (Broadcasting)
print(f"
العمليات مع الأرقام المفردة:")
print(f"a + 10: {a + 10}")
print(f"a * 3: {a * 3}")
print(f"a / 2: {a / 2}")
# الدوال الرياضية
print(f"
الدوال الرياضية:")
angles = np.array([0, np.pi/4, np.pi/2, np.pi])
print(f"الزوايا: {angles}")
print(f"sin: {np.sin(angles)}")
print(f"cos: {np.cos(angles)}")
print(f"tan: {np.tan(angles[:3])}") # تجنب tan(π/2)
# الدوال اللوغاريتمية والأسية
numbers = np.array([1, 2, 4, 8])
print(f"
الأرقام: {numbers}")
print(f"اللوغاريتم الطبيعي: {np.log(numbers)}")
print(f"اللوغاريتم العشري: {np.log10(numbers)}")
print(f"الأسي: {np.exp([1, 2, 3])}")
العمليات الإحصائية
# إنشاء بيانات للتحليل الإحصائي
data = np.random.normal(50, 15, 1000) # 1000 رقم، متوسط=50، انحراف=15
print(f"عدد العناصر: {data.size}")
print(f"أول 10 عناصر: {data[:10]}")
# الإحصائيات الأساسية
print(f"
الإحصائيات الأساسية:")
print(f"المتوسط: {np.mean(data):.2f}")
print(f"الوسيط: {np.median(data):.2f}")
print(f"الانحراف المعياري: {np.std(data):.2f}")
print(f"التباين: {np.var(data):.2f}")
print(f"أقل قيمة: {np.min(data):.2f}")
print(f"أكبر قيمة: {np.max(data):.2f}")
print(f"المدى: {np.ptp(data):.2f}") # Peak to Peak
# الإحصائيات المتقدمة
print(f"
الإحصائيات المتقدمة:")
print(f"المجموع: {np.sum(data):.2f}")
print(f"المجموع التراكمي (أول 5): {np.cumsum(data[:5])}")
print(f"الضرب التراكمي (أول 3): {np.cumprod([1, 2, 3])}")
# النسب المئوية
percentiles = [25, 50, 75, 90, 95]
print(f"
النسب المئوية:")
for p in percentiles:
value = np.percentile(data, p)
print(f"النسبة المئوية {p}%: {value:.2f}")
# العمليات على المحاور
matrix_data = np.random.randint(1, 100, (4, 5))
print(f"
مصفوفة البيانات:
{matrix_data}")
print(f"متوسط كل صف: {np.mean(matrix_data, axis=1)}")
print(f"متوسط كل عمود: {np.mean(matrix_data, axis=0)}")
print(f"مجموع كل صف: {np.sum(matrix_data, axis=1)}")
🔄 تغيير شكل المصفوفات (Reshaping)
إعادة تشكيل المصفوفات مهارة أساسية في الذكاء الاصطناعي:
عمليات إعادة التشكيل
# إنشاء مصفوفة أساسية
original = np.arange(12) # [0, 1, 2, ..., 11]
print(f"المصفوفة الأصلية: {original}")
print(f"الشكل الأصلي: {original.shape}")
# إعادة تشكيل إلى 2D
reshaped_2d = original.reshape(3, 4) # 3 صفوف، 4 أعمدة
print(f"
إعادة تشكيل إلى 3x4:
{reshaped_2d}")
# إعادة تشكيل إلى 3D
reshaped_3d = original.reshape(2, 2, 3) # 2x2x3
print(f"
إعادة تشكيل إلى 2x2x3:
{reshaped_3d}")
# إعادة تشكيل تلقائي
auto_reshape = original.reshape(-1, 2) # -1 يعني احسب تلقائياً
print(f"
إعادة تشكيل تلقائي (-1, 2):
{auto_reshape}")
# تحويل إلى مصفوفة مسطحة
flattened = reshaped_2d.flatten()
print(f"
تحويل إلى مسطح: {flattened}")
# إضافة بعد جديد
expanded = np.expand_dims(original, axis=0) # إضافة بعد في البداية
print(f"
إضافة بعد: {expanded.shape}")
print(f"المحتوى:
{expanded}")
# إزالة الأبعاد الوحيدة
squeezed = np.squeeze(expanded)
print(f"
إزالة الأبعاد الوحيدة: {squeezed.shape}")
# النقل (Transpose)
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(f"
المصفوفة الأصلية:
{matrix}")
print(f"بعد النقل:
{matrix.T}")
🔗 دمج وتقسيم المصفوفات
عمليات مهمة للتعامل مع البيانات الكبيرة:
دمج المصفوفات
# إنشاء مصفوفات للدمج
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(f"المصفوفة a:
{a}")
print(f"المصفوفة b:
{b}")
# الدمج العمودي (vertical stacking)
v_stack = np.vstack((a, b))
print(f"
الدمج العمودي:
{v_stack}")
# الدمج الأفقي (horizontal stacking)
h_stack = np.hstack((a, b))
print(f"
الدمج الأفقي:
{h_stack}")
# الدمج باستخدام concatenate
concat_0 = np.concatenate((a, b), axis=0) # على المحور 0 (الصفوف)
concat_1 = np.concatenate((a, b), axis=1) # على المحور 1 (الأعمدة)
print(f"
الدمج على المحور 0:
{concat_0}")
print(f"الدمج على المحور 1:
{concat_1}")
# دمج مصفوفات 1D
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
combined = np.concatenate((arr1, arr2))
print(f"
دمج مصفوفات 1D: {combined}")
تقسيم المصفوفات
# إنشاء مصفوفة للتقسيم
large_array = np.arange(16).reshape(4, 4)
print(f"المصفوفة الكبيرة:
{large_array}")
# التقسيم العمودي
v_split = np.vsplit(large_array, 2) # تقسيم إلى جزأين عمودياً
print(f"
التقسيم العمودي:")
for i, part in enumerate(v_split):
print(f"الجزء {i+1}:
{part}")
# التقسيم الأفقي
h_split = np.hsplit(large_array, 2) # تقسيم إلى جزأين أفقياً
print(f"
التقسيم الأفقي:")
for i, part in enumerate(h_split):
print(f"الجزء {i+1}:
{part}")
# التقسيم باستخدام split
splits = np.split(np.arange(12), 3) # تقسيم إلى 3 أجزاء متساوية
print(f"
تقسيم مصفوفة 1D:")
for i, part in enumerate(splits):
print(f"الجزء {i+1}: {part}")
# التقسيم في نقاط محددة
custom_split = np.split(np.arange(10), [3, 7]) # تقسيم في النقاط 3 و 7
print(f"
التقسيم المخصص:")
for i, part in enumerate(custom_split):
print(f"الجزء {i+1}: {part}")
🎯 مثال عملي شامل: تحليل درجات الطلاب
الآن سنطبق جميع ما تعلمناه في مثال واقعي:
المشكلة: تحليل أداء الطلاب في 5 مواد
import numpy as np
import matplotlib.pyplot as plt
# إنشاء بيانات وهمية لـ 100 طالب في 5 مواد
np.random.seed(42) # للحصول على نتائج قابلة للتكرار
# أسماء المواد
subjects = ['الرياضيات', 'الفيزياء', 'الكيمياء', 'الأحياء', 'الإنجليزية']
n_students = 100
n_subjects = 5
# إنشاء درجات عشوائية (من 0 إلى 100)
# كل مادة لها متوسط وانحراف معياري مختلف
grades = np.zeros((n_students, n_subjects))
# معدلات مختلفة لكل مادة لتكون أكثر واقعية
subject_means = [75, 70, 68, 72, 78] # متوسط كل مادة
subject_stds = [12, 15, 14, 13, 10] # الانحراف المعياري لكل مادة
for i, (mean, std) in enumerate(zip(subject_means, subject_stds)):
grades[:, i] = np.random.normal(mean, std, n_students)
# التأكد من أن الدرجات بين 0 و 100
grades[:, i] = np.clip(grades[:, i], 0, 100)
print(f"شكل مصفوفة الدرجات: {grades.shape}")
print(f"أول 5 طلاب:
{grades[:5]}")
التحليل الإحصائي الشامل
# 1. الإحصائيات الأساسية لكل مادة
print("📊 الإحصائيات الأساسية لكل مادة:")
print("-" * 60)
for i, subject in enumerate(subjects):
subject_grades = grades[:, i]
print(f"{subject}:")
print(f" المتوسط: {np.mean(subject_grades):.2f}")
print(f" الوسيط: {np.median(subject_grades):.2f}")
print(f" الانحراف المعياري: {np.std(subject_grades):.2f}")
print(f" أقل درجة: {np.min(subject_grades):.2f}")
print(f" أعلى درجة: {np.max(subject_grades):.2f}")
print()
# 2. حساب المعدل العام لكل طالب
student_averages = np.mean(grades, axis=1)
print(f"📈 إحصائيات المعدل العام:")
print(f"متوسط المعدلات: {np.mean(student_averages):.2f}")
print(f"أعلى معدل: {np.max(student_averages):.2f}")
print(f"أقل معدل: {np.min(student_averages):.2f}")
# 3. تصنيف الطلاب حسب الأداء
excellent = np.sum(student_averages >= 90)
very_good = np.sum((student_averages >= 80) & (student_averages < 90))
good = np.sum((student_averages >= 70) & (student_averages < 80))
acceptable = np.sum((student_averages >= 60) & (student_averages < 70))
weak = np.sum(student_averages < 60)
print(f"
🏆 تصنيف الطلاب:")
print(f"ممتاز (90+): {excellent} طالب ({excellent}%)")
print(f"جيد جداً (80-89): {very_good} طالب ({very_good}%)")
print(f"جيد (70-79): {good} طالب ({good}%)")
print(f"مقبول (60-69): {acceptable} طالب ({acceptable}%)")
print(f"ضعيف (<60 div="" weak="">
التحليل المتقدم والاستنتاجات
# 4. العثور على أفضل وأسوأ الطلاب
best_student_idx = np.argmax(student_averages)
worst_student_idx = np.argmin(student_averages)
print(f"🥇 أفضل طالب (رقم {best_student_idx + 1}):")
print(f"المعدل: {student_averages[best_student_idx]:.2f}")
print(f"الدرجات: {grades[best_student_idx]}")
print(f"
📉 الطالب الذي يحتاج مساعدة (رقم {worst_student_idx + 1}):")
print(f"المعدل: {student_averages[worst_student_idx]:.2f}")
print(f"الدرجات: {grades[worst_student_idx]}")
# 5. تحليل المواد الأصعب والأسهل
subject_averages = np.mean(grades, axis=0)
hardest_subject_idx = np.argmin(subject_averages)
easiest_subject_idx = np.argmax(subject_averages)
print(f"
📚 تحليل المواد:")
print(f"أصعب مادة: {subjects[hardest_subject_idx]} (متوسط: {subject_averages[hardest_subject_idx]:.2f})")
print(f"أسهل مادة: {subjects[easiest_subject_idx]} (متوسط: {subject_averages[easiest_subject_idx]:.2f})")
# 6. العثور على الطلاب المتفوقين في مادة معينة
math_grades = grades[:, 0] # درجات الرياضيات
top_math_students = np.where(math_grades >= 90)[0]
print(f"
🧮 الطلاب المتفوقون في الرياضيات ({len(top_math_students)} طالب):")
for student_idx in top_math_students[:5]: # أول 5 فقط
print(f"الطالب {student_idx + 1}: {math_grades[student_idx]:.2f}")
# 7. حساب معامل الارتباط بين المواد
correlation_matrix = np.corrcoef(grades.T)
print(f"
🔗 معامل الارتباط بين المواد:")
print("(1.0 = ارتباط تام، 0.0 = لا ارتباط، -1.0 = ارتباط عكسي)")
for i, subject1 in enumerate(subjects):
for j, subject2 in enumerate(subjects):
if i < j: # لتجنب التكرار
corr = correlation_matrix[i, j]
print(f"{subject1} - {subject2}: {corr:.3f}")
استخدام NumPy في التعلم الآلي
# 8. تطبيق مفاهيم التعلم الآلي
# تحويل الدرجات إلى تصنيفات (0: ضعيف، 1: جيد، 2: ممتاز)
def classify_performance(average):
if average >= 85:
return 2 # ممتاز
elif average >= 70:
return 1 # جيد
else:
return 0 # ضعيف
# تطبيق التصنيف على جميع الطلاب
performance_labels = np.array([classify_performance(avg) for avg in student_averages])
print(f"
🏷️ توزيع التصنيفات:")
print(f"ضعيف (0): {np.sum(performance_labels == 0)} طالب")
print(f"جيد (1): {np.sum(performance_labels == 1)} طالب")
print(f"ممتاز (2): {np.sum(performance_labels == 2)} طالب")
# 9. تحضير البيانات للتعلم الآلي
# تطبيع البيانات (Normalization) - مهم جداً في ML
normalized_grades = (grades - np.mean(grades, axis=0)) / np.std(grades, axis=0)
print(f"
📏 البيانات بعد التطبيع:")
print(f"متوسط كل مادة: {np.mean(normalized_grades, axis=0)}")
print(f"الانحراف المعياري لكل مادة: {np.std(normalized_grades, axis=0)}")
# 10. حساب المسافة الإقليدية بين الطلاب
# مثال: المسافة بين أول طالبين
student1 = normalized_grades[0]
student2 = normalized_grades[1]
euclidean_distance = np.sqrt(np.sum((student1 - student2) ** 2))
print(f"
📐 المسافة الإقليدية بين الطالب 1 والطالب 2: {euclidean_distance:.3f}")
# العثور على أقرب طالب للطالب الأول
distances = np.sqrt(np.sum((normalized_grades - student1) ** 2, axis=1))
closest_student_idx = np.argsort(distances)[1] # [1] لتجنب الطالب نفسه
print(f"أقرب طالب للطالب الأول هو الطالب رقم: {closest_student_idx + 1}")
print(f"المسافة: {distances[closest_student_idx]:.3f}")
🎯 ماذا تعلمنا من هذا المثال الشامل؟
- إنشاء البيانات: استخدام np.random لإنشاء بيانات واقعية
- التحليل الإحصائي: حساب المتوسط والانحراف والنسب المئوية
- الفهرسة المتقدمة: العثور على أفضل وأسوأ الطلاب
- العمليات على المحاور: حساب المعدلات للطلاب والمواد
- الشروط المنطقية: تصنيف الطلاب حسب الأداء
- معالجة البيانات: التطبيع والتحضير للتعلم الآلي
- حساب المسافات: أساس خوارزميات التجميع والتصنيف
🎯 تمارين عملية
تمرين 1: تحليل بيانات المبيعات
أنشئ مصفوفة تمثل مبيعات 12 شهر لـ 5 منتجات:
- احسب إجمالي المبيعات لكل منتج
- احسب متوسط المبيعات الشهرية
- اعثر على أفضل وأسوأ شهر في المبيعات
- احسب معدل النمو الشهري
تمرين 2: معالجة الصور الأساسية
استخدم NumPy لمعالجة صورة (مصفوفة 3D):
- أنشئ صورة عشوائية 100x100x3 (RGB)
- حول الصورة إلى رمادي
- طبق مرشح تمويه بسيط
- اقطع جزء من الصورة
تمرين 3: محاكاة البيانات المالية
محاكاة أسعار الأسهم:
- أنشئ بيانات أسعار يومية لـ 5 أسهم لمدة سنة
- احسب العائد اليومي لكل سهم
- احسب التقلبات (Volatility)
- اعثر على أفضل وأسوأ الأسهم أداءً
⚡ نصائح للأداء الأمثل
🚀 كيفية تحسين أداء NumPy:
- استخدم العمليات المتجهة: تجنب الحلقات واستخدم عمليات NumPy
- اختر نوع البيانات المناسب: int32 بدلاً من int64 إذا كان كافياً
- استخدم المصفوفات المتجاورة: np.ascontiguousarray() للذاكرة المتجاورة
- تجنب النسخ غير الضروري: استخدم views بدلاً من copies
- استخدم Broadcasting: بدلاً من تكرار المصفوفات
⚠️ أخطاء شائعة يجب تجنبها:
- خلط الأبعاد: تأكد من توافق أشكال المصفوفات
- تعديل المصفوفات الأصلية: استخدم .copy() عند الحاجة
- استخدام Python loops: استخدم NumPy functions بدلاً منها
- تجاهل نوع البيانات: قد يؤدي لفقدان دقة أو overflow
📝 ملخص الدرس
في هذا الدرس المفصل تعلمنا:
- ✅ ما هو NumPy: أساس الحوسبة العلمية في Python
- ✅ السرعة والأداء: لماذا NumPy أسرع 50-100 مرة
- ✅ إنشاء المصفوفات: طرق متعددة ومرنة
- ✅ أنواع البيانات: تحسين الذاكرة والأداء
- ✅ الفهرسة والتقطيع: الوصول المتقدم للبيانات
- ✅ العمليات الرياضية: دوال شاملة ومحسنة
- ✅ إعادة التشكيل: مرونة في التعامل مع الأبعاد
- ✅ الدمج والتقسيم: إدارة البيانات الكبيرة
- ✅ مثال عملي شامل: تحليل درجات الطلاب
- ✅ تطبيقات التعلم الآلي: تحضير البيانات والمسافات
➡️ الدرس التالي
في الدرس التالي سنتعلم Pandas لمعالجة البيانات:
- قراءة البيانات من ملفات CSV وExcel
- تنظيف وتحويل البيانات
- التحليل الإحصائي المتقدم
- التعامل مع البيانات المفقودة
- دمج وربط مجموعات البيانات المختلفة
- إنشاء تقارير تحليلية شاملة
.png "AI بالعربي"){kind=logo}