python

بالتأكيد، يمكنك تسريع عملية إنشاء تقرير الأداء باستخدام الأتمتة والبرمجة النصية. عندما تستخدم أمر ADB top في وضع سطر الأوامر، يمكنك توجيه النتائج إلى ملف نصي وحفظه تلقائيًا في مسار البطاقة الذاكرة SD. بمجرد حصولك على هذه السجلات، يمكنك تقسيم القيم باستخدام Excel باستخدام خيار “تقسيم النص إلى أعمدة”.

لكن، هل هناك سكريبت أو ماكرو يمكن استخدامه لتسريع هذه العملية؟ بالطبع، هناك العديد من الطرق لتحقيق ذلك باستخدام الأتمتة. يمكنك استخدام لغة برمجة مثل Python أو VBA لكتابة سكريبت أو ماكرو يقوم بقراءة الملف النصي المحصل عليه من ADB top، ومن ثم يقوم بتحليل وتحويل البيانات بشكل تلقائي دون الحاجة إلى تدخل يدوي.

على سبيل المثال، يمكنك استخدام Python لقراءة الملف النصي، ومن ثم تحليل البيانات وتقسيمها وتنظيفها، ثم حفظها في ملف Excel بتنسيق ملائم. بالإضافة إلى ذلك، يمكنك كتابة ماكرو في Excel باستخدام VBA لتنفيذ الخطوات نفسها داخل برنامج Excel مباشرة دون الحاجة إلى استخدام برنامج خارجي.

بالاعتماد على الطريقة التي تختارها وعلى مهارات البرمجة الخاصة بك، يمكنك إنشاء سكريبت أو ماكرو يمكنه تنفيذ هذه العمليات بسرعة وكفاءة، مما يوفر الوقت والجهد في إعداد التقارير بشكل متكرر.

بالتأكيد، دعني أوسع عن هذا الموضوع.

عملية إعداد تقرير الأداء يمكن أن تكون مهمة مملة ومكلفة للوقت، خصوصاً عندما تكون تقوم بتكرارها بانتظام. ولذلك، استخدام الأتمتة لتسريع هذه العملية هو خيار ذكي يمكن أن يوفر الوقت والجهد.

إذا كنت ترغب في استخدام Python، يمكنك استخدام مكتبات مثل Pandas وopenpyxl لتسهيل عملية قراءة الملف النصي وتحليل البيانات وتخزينها في ملف Excel. على سبيل المثال، يمكنك استخدام Pandas لقراءة ملف النصي وتحويل البيانات إلى هيكل بيانات قابل للتحليل، ثم استخدام openpyxl لكتابة هذه البيانات في ملف Excel بتنسيق ملائم.

أما بالنسبة لـ VBA في Excel، يمكنك استخدام المسجل المصور للتسجيل وتنفيذ الخطوات التي تريدها يدويًا، ثم تحرير الكود المولد لتكييفه مع احتياجاتك الخاصة. يمكنك أيضًا الاستفادة من مجتمعات البرمجة على الإنترنت حيث يمكنك العثور على العديد من الأمثلة والموارد التي تساعدك في تطوير ماكرو مخصصة تلبي احتياجات تقرير الأداء الخاص بك.

عند تحسين عملية تقرير الأداء باستخدام الأتمتة، ستجد أن الوقت الذي كنت تقضيه يدويًا في هذه المهمة يمكن أن يختصر بشكل كبير، مما يتيح لك التركيز على المهام الأكثر إبداعًا وأهمية في عملك.

بالتأكيد، عزيزي القارئ، في مكتبة Pandas الرائعة هناك طرق عديدة لفحص أنواع البيانات في جميع الأعمدة في إطار البيانات. يمكننا استخدام العديد من الطرق المختلفة لتحقيق ذلك بسهولة.

أولًا، يمكنك استخدام الخاصية dtypes المدمجة للإطار البيانات للحصول على سلسلة تحتوي على أنواع البيانات لكل عمود. يمكنك استدعاء هذه الخاصية كما هو موضح في المثال التالي:

pythonCopy code
import pandas as pd

# قم بإنشاء إطار بيانات تجريبي
data = {'A': [1, 2, 3], 'B': [4.0, 5.0, 6.0], 'C': ['x', 'y', 'z']}
df = pd.DataFrame(data)

# اطبع أنواع البيانات لكل عمود
print(df.dtypes)

هذا سيطبع أنواع البيانات لكل عمود في الإطار البيانات.

ثانيًا، يمكنك استخدام الطريقة info() للإطار البيانات للحصول على معلومات مفصلة تشمل أنواع البيانات بالإضافة إلى معلومات أخرى مثل العدد الكلي للقيم غير المفقودة في كل عمود. يمكنك استدعاء هذه الطريقة كما هو موضح في المثال التالي:

pythonCopy code
import pandas as pd

# قم بإنشاء إطار بيانات تجريبي
data = {'A': [1, 2, 3], 'B': [4.0, 5.0, 6.0], 'C': ['x', 'y', 'z']}
df = pd.DataFrame(data)

# اطبع معلومات الإطار البيانات
print(df.info())

هذا سيطبع معلومات مفصلة حول الإطار البيانات بما في ذلك أنواع البيانات لكل عمود، وعدد القيم غير المفقودة، واستخدام الذاكرة، وغير ذلك الكثير.

باستخدام هذين الأسلوبين، يمكنك بسهولة فحص أنواع البيانات في جميع الأعمدة في إطار البيانات الخاص بك.

بالطبع، دعني أضيف المزيد من التفاصيل للمقال:

علاوة على الطرق المذكورة أعلاه، يمكنك أيضًا استخدام الطريقة select_dtypes() لتحديد الأعمدة التي تحتوي على نوع معين من البيانات، مثل الأعمدة العددية أو النصية. على سبيل المثال:

pythonCopy code
import pandas as pd

# قم بإنشاء إطار بيانات تجريبي
data = {'A': [1, 2, 3], 'B': [4.0, 5.0, 6.0], 'C': ['x', 'y', 'z']}
df = pd.DataFrame(data)

# اطبع أعمدة البيانات العددية
print(df.select_dtypes(include='number'))

# اطبع أعمدة البيانات النصية
print(df.select_dtypes(include='object'))

هذا سيعرض الأعمدة العددية والنصية في الإطار البيانات بشكل منفصل.

بالإضافة إلى ذلك، يمكنك أيضًا استخدام الطريقة infer_objects() لتحويل أنواع البيانات الخام إلى أنواع بيانات متوافقة مع Pandas بشكل أفضل. قد يكون هذا مفيدًا في حالة تحميل بيانات من مصدر خارجي مثل ملف CSV وتحديد أنواع البيانات تلقائيًا بشكل صحيح. على سبيل المثال:

pythonCopy code
import pandas as pd

# قم بتحميل إطار البيانات من ملف CSV
df = pd.read_csv('data.csv')

# قم بتحويل أنواع البيانات
df = df.infer_objects()

هذا يقوم بتحويل أنواع البيانات لكل عمود إلى الأنواع الأكثر توافقًا مع البيانات الفعلية.

باستخدام هذه الطرق المختلفة، يمكنك بسهولة فحص أنواع البيانات في جميع الأعمدة في إطار بيانات Pandas الخاص بك وضمان توافقها مع متطلبات تحليل البيانات الخاصة بك.

هذا الكود الذي قمت بطرحه هو جزء من دورة تكرارية تستخدم في لغة البرمجة Python، ويستخدم عملية تكرارية للوصول إلى عناصر معينة في متغير question على مدى 28 تكرارًا متتاليًا. لفهم الشيفرة بشكل أفضل، سأقوم بتفسيرها خطوة بخطوة.

أولاً، دعونا ننظر إلى الجزء الرئيسي من الكود:

pythonCopy code
for i in range(t, t + 28):
    transmission.append(question[i%len(question)])

هنا يتم استخدام حلقة for لتكرار عبر مجموعة معينة من الأرقام، حيث يبدأ المؤشر i من t ويستمر حتى t + 28 - 1، أي بمجموع 28 تكراراً.

بينما يتم إضافة العناصر إلى قائمة جديدة تسمى transmission باستخدام السطر التالي:

pythonCopy code
transmission.append(question[i%len(question)])

هنا، يتم استخدام المعامل % (والمعروف باسم “عملية القسمة المتبقية” أو “عملية الباقي”) للحصول على باقي القسمة على طول المتغير question. هذا يعني أنه بمجرد أن يصل المؤشر i إلى نهاية question، سيعود ويبدأ من البداية مرة أخرى.

هذا يعني أن الكود يقوم بتكرار عبر question بحيث يبدأ من البداية بعدما يصل إلى نهايته. وهكذا، يتم تضمين جميع العناصر من question في transmission على مدى 28 تكراراً.

إذا كان هناك أي استفسار آخر، فلا تتردد في طرحه!

بالطبع، دعني أوسع الشرح لفهم الكود بشكل أعمق.

عندما نلقي نظرة على الكود، نجد استخداماً للحلقة for التي تُستخدم لتكرار عبر مجموعة معينة من الأرقام. في هذه الحالة، يتم تعريف المجموعة باستخدام range() والتي تبدأ من t وتستمر حتى t + 28 - 1. بمعنى آخر، يتم تكرار الحلقة لمدة 28 مرة، بدءًا من t وحتى t + 27.

خلال كل تكرار، يتم استدعاء العنصر question[i%len(question)] وإضافته إلى قائمة جديدة تسمى transmission. هنا تأتي عملية % في العمل، حيث يُستخدم للحصول على الباقي من القسمة. عندما يصل المؤشر i إلى نهاية question، يُعيد % المؤشر إلى بداية question مرة أخرى، مما يسمح بالوصول المتكرر للعناصر في question دون الحاجة إلى مواجهة خطأ في الفهرس.

هذا النوع من اللفّة يُستخدم عادةً عندما يكون لدينا مجموعة من العناصر نريد تكرارها بشكل مستمر بدون نهاية، حيث يُمكن استخدام % لضمان عدم الخروج عن حدود المجموعة.

في النهاية، تقوم الحلقة بإنشاء قائمة جديدة transmission تحتوي على نفس العناصر الموجودة في question، ولكن بترتيب يتكرر مع تغير موضع البداية مع كل دورة.

هذا النوع من الأساليب المبرمجة يُستخدم عادة في تشفير وفك تشفير البيانات أو في مجالات أخرى مثل معالجة الإشارات الرقمية حيث يحتاج المستخدم إلى تحليل البيانات بشكل دوري.

في النهاية، يجب على المطورين فهم الأساليب المختلفة للتكرار واستخدامها بشكل مناسب وفقًا لمتطلبات مشروعهم المحددة.

القدرة على تحقيق مثل هذه العملية باستخدام قائمة التركيب (List comprehension) تعتبر تحديًا بسبب الحاجة إلى تعيين متغيرات داخل القائمة. عادةً ما يتم استخدام التعبيرات للإنتاج المباشر لقائمة بناءً على عناصر من القائمة الأصلية دون الحاجة إلى متغيرات مؤقتة. ومع ذلك، يمكن العمل حول هذا العائق باستخدام دالة مساعدة أو الاستفادة من المعالجة المسلسلة.

يمكن تحقيق الهدف المطلوب باستخدام قائمة التركيب مع دالة مساعدة لتحويل السلاسل المقسمة إلى النوع المناسب وإزالة الفراغات الزائدة. هناك أيضًا الخيار المتاح باستخدام التعبيرات اللامتزامنة، وهو شيء مماثل لاستخدام دالة مساعدة، ولكنه يستخدم تقنيات مختلفة.

لنقم بتنفيذ ذلك باستخدام دالة مساعدة:

pythonCopy code
inputs = ["1, foo, bar", "2, tom, jerry"]

# دالة مساعدة لتحويل السلسلة المقسمة إلى النوع المناسب وإزالة الفراغات الزائدة
def process_string(s):
    parts = s.split(",")
    return [int(parts[0]), parts[1].strip(), parts[2].strip()]

# استخدام قائمة التركيب مع الدالة المساعدة
outputs = [process_string(s) for s in inputs]

print(outputs)  # [[1, 'foo', 'bar'], [2, 'tom', 'jerry']]

هذا الحل يسمح بالتحكم في عملية التحويل بشكل أكبر، مما يوفر مرونة أكبر في التعامل مع البيانات.

بالطبع، دعنا نوسّع المقال لنشمل المزيد من التفاصيل حول كيفية استخدام دوال المساعدة في قوائم التركيب وكيف يمكن أن تُسهِّل هذه الطريقة عملية تنظيم الشفرة وجعلها أكثر فعالية.

في بيئة Python، قوائم التركيب (List comprehensions) تُعَدُّ أداة قوية لإنشاء قوائم جديدة بشكل مُشَتَقٍّ من قوائم موجودة بطريقة مُنظَّمة ومُدمجة. ومع ذلك، في بعض الحالات، قد يكون الأمر معقدًا لتنفيذ تحويلات معينة بسبب الحاجة إلى معالجة متعددة لكل عنصر. لحل هذه المشكلة، يمكن استخدام دوال المساعدة لتبسيط الشفرة وجعلها أكثر قراءةً وفهمًا.

في المثال السابق، قمنا باستخدام دالة المساعدة process_string لتحويل السلسلة المقسمة إلى الأنواع المناسبة وإزالة الفراغات الزائدة. ومع ذلك، يمكن توسيع هذه الفكرة بشكل أكبر لتضمين المزيد من العمليات الخاصة بتحويل البيانات.

مثلاً، إذا كانت لدينا قائمة من الأسماء ونريد تحويلها جميعًا إلى أحرف كبيرة، يمكننا استخدام دالة مساعدة لتنفيذ هذه العملية. إليك مثالًا بسيطًا:

pythonCopy code
# قائمة الأسماء
names = ["alice", "bob", "charlie"]

# دالة مساعدة لتحويل الأسماء إلى أحرف كبيرة
def capitalize_name(name):
    return name.upper()

# استخدام قائمة التركيب مع الدالة المساعدة
capitalized_names = [capitalize_name(name) for name in names]

print(capitalized_names)  # ['ALICE', 'BOB', 'CHARLIE']

باستخدام دوال المساعدة، يمكننا تنظيم وتوسيع الشفرة بشكل أكبر، كما يمكن تعيين أسماءٍ واضحة ومعبرة للدوال، مما يجعل الشفرة أكثر قابلية للصيانة وفهمًا.

بالاعتماد على هذه الأساسيات، يمكن للمطوِّرين تنفيذ عمليات معقدة أخرى باستخدام دوال المساعدة داخل قوائم التركيب، مما يجعل الشفرة أكثر فعالية وسهولة في القراءة والصيانة.

لدى مجموعة Pandas العديد من الأدوات القوية للتلاعب بالبيانات، ومن بين هذه الأدوات توجد وظيفة diff() التي تستخدم عادةً لحساب الفروقات بين القيم في الأعمدة الرقمية. ومع ذلك، عند التعامل مع القيم النصية، لا يمكن استخدام diff() بشكل مباشر للكشف عن التغييرات في القيم.

لحل هذه المشكلة، يمكن استخدام وظيفة shift() مع تحويل القيم النصية إلى قيم رقمية من خلال تعيين رموز فريدة لكل قيمة نصية ممكنة. يمكن ذلك عن طريق إنشاء قاموس للتعيين بين القيم النصية والقيم الرقمية، ثم استخدام هذا القاموس لتحويل القيم. بعد ذلك، يمكن استخدام وظيفة diff() لحساب الفروقات بين القيم الرقمية.

في الخطوات التالية، سأوضح كيفية تنفيذ هذه العملية بالتفصيل:

1. إنشاء قاموس لتعيين قيم رقمية فريدة لكل قيمة نصية ممكنة في العمود.
2. تحويل القيم النصية إلى قيم رقمية باستخدام القاموس.
3. استخدام وظيفة shift() لمقارنة القيم الرقمية الحالية بالقيم الرقمية السابقة.
4. تطبيق شرط لتحديد المواقع التي تغيرت فيها القيم.
5. تحويل القيم الرقمية الناتجة إلى قيم نصية باستخدام القاموس.

لنبدأ بتنفيذ الخطوات المذكورة أعلاه باستخدام مكتبة Pandas:

بدأنا الآن في تنفيذ الخطوات المذكورة أعلاه باستخدام مكتبة Pandas:

أولاً، نقوم بإنشاء قاموس لتعيين قيم رقمية فريدة لكل قيمة نصية ممكنة في العمود. على سبيل المثال، إذا كانت القيم النصية هي “Blue”، “Red”، و “Yellow”، يمكننا تعيين لكل منها قيمة رقمية فريدة، مثل 1، 2، و 3 على التوالي.

pythonCopy code
value_mapping = {'Blue': 1, 'Red': 2, 'Yellow': 3}

ثم، نقوم بتحويل القيم النصية إلى قيم رقمية باستخدام القاموس المعرف سابقًا. يمكن القيام بذلك باستخدام الوظيفة map() في Pandas.

pythonCopy code
dataframe['ColumnB_numeric'] = dataframe['ColumnB'].map(value_mapping)

بعد ذلك، نستخدم وظيفة shift() لمقارنة القيم الرقمية الحالية بالقيم الرقمية السابقة، وذلك للعثور على الفروقات بينها.

pythonCopy code
dataframe['changed_numeric'] = dataframe['ColumnB_numeric'].diff()

ثم، نطبق شرطًا لتحديد المواقع التي تغيرت فيها القيم، حيث نراقب الفروقات ونرغب في تحديد المواقع التي قيمتها غير صفرية.

pythonCopy code
dataframe['changed'] = dataframe['changed_numeric'].apply(lambda x: 1 if x != 0 else 0)

وأخيرًا، نقوم بتحويل القيم الرقمية الناتجة إلى قيم نصية باستخدام القاموس.

pythonCopy code
dataframe['changed'] = dataframe['changed'].map({1: 'Yes', 0: 'No'})

الآن، بعد تنفيذ هذه الخطوات، سيتم إضافة عمود إلى الإطار البيانات يحتوي على قيم “Yes” في المواقع التي تغيرت فيها القيم، وقيم “No” في المواقع التي لم تتغير فيها القيم.

يمكنك الآن استخدام هذا الإطار البيانات لتحديد الصفوف التي تغيرت فيها القيم والتي لم تتغير فيها، وذلك باستخدام العمود الجديد الذي تم إنشاؤه.

لقد استخدمت الوظيفة dataframe.describe() لتوليد ملخص إحصائي لعمود “AMNT” في إطار البيانات، ولكنك تواجه مشكلة في ظهور الأرقام بصيغة العلمية. الحل البسيط لهذه المشكلة هو تعيين خيار float_format إلى دالة pd.options.display لتعطيل العلمية وتعيينها إلى التنسيق القياسي.

يمكنك استخدام الكود التالي لتحقيق ذلك:

pythonCopy code
import pandas as pd

# تعيين تنسيق الأرقام العائمة
pd.options.display.float_format = '{:.2f}'.format

# عرض ملخص إحصائي
print(contrib_df["AMNT"].describe())

بعد تنفيذ الكود أعلاه، يجب أن تظهر الأرقام الآن بتنسيق قياسي بدلاً من العلمي.

يرجى ملاحظة أنني قمت بافتراض أنك تستخدم مكتبة Pandas في Python لمعالجة البيانات، وبالتالي استخدمت الوظائف المتوفرة في هذه المكتبة لحل مشكلتك.

في هذا المقال، سنتعمق قليلاً في الطريقة التي تعمل بها هذه الحلول وكيفية تطبيقها بشكل أفضل في بيئة العمل الخاصة بك.

فهم مشكلة العرض العلمي

عندما تقوم بتحليل البيانات باستخدام مكتبة Pandas في Python، فإن واحدة من الأوامر الأكثر استخدامًا هي dataframe.describe()، التي تقدم ملخصًا إحصائيًا للبيانات، بما في ذلك العدد الإجمالي للعناصر، والمتوسط، والانحراف المعياري، والحدود الدنيا والعليا، والكمية في الربع الأول، والنصف، والثالث.

ومع ذلك، في بعض الأحيان، يمكن أن يظهر الأرقام بصيغة العلمية بدلاً من التنسيق القياسي، وهو ما قد لا يكون مفيدًا أو ملائمًا، خاصة عندما يتم تقديم البيانات لشريحة واسعة من الجمهور. على سبيل المثال، قد يكون من الأفضل عرض الأرقام بتنسيق قياسي عند التقديم للعملاء أو المشاركين في البحث.

الحل: تعطيل العرض العلمي

لحل هذه المشكلة، يمكننا استخدام الخيار float_format في دالة pd.options.display في Pandas. عندما نقوم بتعيين هذا الخيار، يتم تطبيق التنسيق الذي نحدده على جميع الأرقام العائمة التي يتم عرضها.

في المثال السابق، استخدمنا الكود التالي لتحقيق ذلك:

pythonCopy code
import pandas as pd

# تعيين تنسيق الأرقام العائمة
pd.options.display.float_format = '{:.2f}'.format

# عرض ملخص إحصائي
print(contrib_df["AMNT"].describe())

الاستفادة القصوى من الحل

عند تطبيق هذا الحل، يجب أن نأخذ في الاعتبار أن تغيير تنسيق الأرقام العائمة يؤثر على كل الأرقام التي يتم عرضها في بيئة Python الحالية، وليس فقط على نتائج dataframe.describe()، لذا يجب أن نكون حذرين عند استخدام هذا الحل ونتأكد من أنه يتناسب مع الاستخدام الآخر في البرنامج.

الختام

في النهاية، يمكننا أن نرى كيف يمكن استخدام خيار float_format في دالة pd.options.display لتعطيل العرض العلمي وتطبيق تنسيق قياسي على الأرقام العائمة في مكتبة Pandas في Python. هذا الحل يسمح لنا بتقديم البيانات بطريقة أكثر وضوحًا وسهولة فهمًا للمستخدمين، مما يزيد من جاذبية التقارير والتحليلات التي نقدمها.

بما أنك تسعى لتنفيذ الكود الذي يقوم بطباعة الأعداد المضاعفة للعدد 3 بين 0 و 100 (شاملاً) التي يمكن قسمها على 2، سأقدم لك شرحاً مفصلاً لكيفية تحقيق ذلك بشكل صحيح وفعّال.

أولاً وقبل كل شيء، دعنا ننظر إلى الكود الذي كتبته:

pythonCopy code
num = range(0, 101, 3)
list = []
if num % 3 == 0:
    list.append
print(list)

هناك بعض الأخطاء في هذا الكود التي يجب تصحيحها. دعوني أشرح لك:

1. السطر الأول (num = range(0, 101, 3)) يقوم بإنشاء متغير num ويعطيه قيمة مدى تحتوي على جميع الأعداد الذين يبدأون من 0 وينتهون بـ 100 مع خطوة تساوي 3، وهذا صحيح.
2. السطر الثاني (list = []) يقوم بإنشاء قائمة فارغة تدعى list، وهذا صحيح أيضاً.
3. السطر الثالث يحتوي على خطأ، لأن num ليس عبارة عن عدد واحد بل هو مدى. لذا، لا يمكنك استخدام العمليات الحسابية المباشرة عليه. بدلاً من ذلك، يجب عليك استخدام حلقة for لتحقق من كل عنصر في المدى.
4. في السطر الرابع، يقوم بتطبيق شرط if على num مباشرة، وهذا لن يعمل بالطريقة التي تتوقعها. يجب عليك تحقق من كل عنصر في المدى بدلاً من ذلك.
5. السطر الخامس يستخدم الدالة append دون تمرير أي قيمة إليها، ولذا لن يتم إضافة أي شيء إلى القائمة.
6. السطر السادس يطبع القائمة الفارغة.

والآن، دعني أعطيك الكود الصحيح لتحقيق المطلوب:

pythonCopy code
result = []
for i in range(0, 101, 3):
    if i % 2 == 0:
        result.append(i)
print(result)

هذا الكود يقوم بالتالي:

1. يقوم بإنشاء قائمة فارغة تسمى result لتخزين الأعداد التي تم طباعتها.
2. يستخدم حلقة for لتحقق من كل عنصر في المدى من 0 إلى 100 بخطوة تساوي 3.
3. داخل الحلقة، يتحقق من ما إذا كان العدد قابل للقسمة على 2 بدون باقي، وإذا كان الشرط صحيحًا، يتم إضافة العدد إلى القائمة result.
4. في النهاية، يطبع الكود الأرقام التي تمت إضافتها إلى القائمة result.

باستخدام هذا الكود، يجب أن تحصل على النتيجة المطلوبة، وهي قائمة تحتوي على الأعداد المطلوبة.

بالطبع، دعنا نستكمل المقال بشكل طبيعي. ها هو:

بعد تنفيذ الكود الصحيح، يتمكن المستخدم من الحصول على قائمة بجميع الأعداد التي تم طباعتها، والتي تمثل الأعداد المضاعفة للعدد 3 بين 0 و100 (شاملة) والتي يمكن قسمها على 2 بدون باقي.

ومن الجدير بالذكر أن هذا الكود يعتمد على مفهومين أساسيين في برمجة Python:

1. الحلقات (for loop): تُستخدم لتنفيذ مجموعة من الأوامر بشكل تكراري على عدد محدد من العناصر، مثل الأرقام في هذه الحالة. تسمح الحلقات للمطورين بتكرار عمليات معينة بسهولة على مجموعة معينة من البيانات.

2. الشروط (if statement): تُستخدم لتحديد تنفيذ الأوامر بناءً على شروط معينة. في هذا السياق، نستخدم شرطًا للتحقق مما إذا كان العدد قابلًا للقسمة على 2 بدون باقي أم لا.

باستخدام هذه الأدوات، يمكن للمطورين كتابة برامج مرنة وقوية لحل مجموعة متنوعة من المشاكل، سواء كانت بسيطة مثل هذه الحالة أو أكثر تعقيداً.

بالنظر إلى المستقبل، يمكن للمطورين تطوير هذا الكود ليتناسب مع احتياجات مختلفة، مثل تغيير الشرط ليشمل عوامل أخرى مثل 5 بدلاً من 2، أو تحديد مدى أكبر من الأعداد. كما يمكن أيضًا تضمين هذا الكود كجزء من تطبيق أو برنامج أكبر.

باختصار، توفر Python وغيرها من لغات البرمجة أدوات قوية لتحقيق العديد من المهام، سواء كانت بسيطة أو معقدة، وتعكس هذه الحالة كيف يمكن للمطورين استخدام هذه الأدوات بشكل إبداعي لحل المشاكل بطرق جديدة وفعالة.

هل هناك أي تعديلات أو إضافات ترغب في إجرائها في المقال؟

في عالم البرمجة بلغة Python، فإن فهم استخدام الكلمة المفتاحية “self” في الكلاسات (الصفوف) يعتبر مهمًا لفهم مفهوم البرمجة الشيئية. عندما تنشئ كلاسًا جديدًا في Python، فإنك تعرف عناصر البيانات والأساليب التي تتعامل معها هذه العناصر. عندما تنشئ دالة (أو طريقة) داخل الكلاس، يجب أن تضع الكلمة “self” كمعامل أول لهذه الدالة.

في سياقك، عندما تقوم بتعريف الدالة __init__ في الكلاس، فإن الهدف هو تهيئة الكائنات التي تنشئها من الكلاس. باستخدام الكلمة “self”، تعرف Python أن الخصائص (أو المتغيرات) التي تحددها في الدالة __init__ تنتمي إلى الكائن الذي تم إنشاؤه. عندما تقوم بكتابة self.a = a، فإنك تخبر Python أنه يجب تخزين قيمة المتغير “a” في الكائن الحالي باسم “a”. وبفضل ذلك، يمكنك الوصول إلى هذه المتغيرات داخل أي دالة أخرى في الكلاس باستخدام self.a.

بشكل أساسي، الكلمة “self” تشير إلى الكائن الذي يتم إنشاؤه من الكلاس. بدون استخدام “self”، لا يمكنك الوصول إلى الخصائص أو الأساليب داخل الكلاس بشكل صحيح.

بالنسبة لسؤالك الثاني حول الفرق بين تعريف الكلاس مع المعلمة وبدونها، هناك بعض النقاط التي يجب التوضيح عنها:

• class hello(object):: هذا التعريف يستخدم تعبيرًا يشير إلى أن الكلاس “hello” يرث من الكلاس “object”، الذي هو الكلاس الأساسي في Python.
• class hello():: هنا، لا توجد معلمة تعريفية للكلاس. يعتبر هذا التعريف بسيطًا ولا يحتوي على تفاصيل إضافية.
• class hello:: هذا التعريف أيضًا بسيط ويشير إلى تعريف كلاس بسيط بدون معلمات.

في Python 3، يتم افتراض التعريف الأول (class hello(object):) والثاني (class hello():) كنفس الشيء، حيث يرث الكلاس من الكلاس الأساسي “object” تلقائيًا. ومع ذلك، يفضل الكثيرون استخدام التعبير الكامل class hello(object): للوضوح والقراءة الجيدة. بينما في Python 2، كان الفرق أكبر بين الطرق، حيث كان class hello: يعني أن الكلاس لا يرث من “object”، بينما class hello(object): يعني أنه يرث من “object”.

باختصار، استخدام self في Python يساعد في تمييز متغيرات الكائنات الفردية داخل الكلاس، بينما تعريف الكلاس بوضوح يؤدي إلى قراءة الشيفرة بشكل أفضل وتوضيح العلاقات الوراثية في الكود.

بالتأكيد، سنواصل توسيع المقال لفهم عميق لهذه المفاهيم.

إذا نظرنا إلى الكود الذي قدمته، يمكننا فهم كيفية عمل الكلاسات في Python ولماذا يعتبر استخدام “self” ضرورياً.

عندما تقوم بإنشاء كائن من الكلاس، مثل hh = ge(1, 2)، يتم استدعاء دالة __init__ تلقائياً. هذه الدالة تستخدم لتهيئة الكائن، وتأخذ المعاملات التي تم تمريرها إليها عند إنشاء الكائن. في حالتك، فإنها تأخذ معاملين “a” و “b” وتضعهما في الخصائص “p” و “l” بالترتيب.

باستخدام الـ”self”، يمكنك الوصول إلى هذه الخصائص في أي دالة داخل الكلاس. على سبيل المثال، في دالة ff()، تقوم بإنشاء متغير جديد “aaa” باستخدام قيمتي “p” و “l” المخزنة في الكائن الحالي. هذا يتيح لك استخدام البيانات التي تم تخزينها في الكائن بسهولة داخل الكلاس.

بالنسبة للفرق بين تعريف الكلاس بوجود معلمة وعدمها، يعتمد الأمر على الإصدار من Python الذي تستخدمه. في Python 3، لا يوجد فرق كبير بين تلك الطرق. ومع ذلك، في Python 2، كان هناك بعض الاختلافات في التصرف بين class hello: و class hello(object):. في الوقت الحالي، يُنصح بتحديد object لضمان التوافق مع إصدارات Python المستقبلية ولتوضيح الرمز للقراء.

بشكل عام، فهم عمل الكلاسات في Python وكيفية استخدام “self” يعتبر أمرًا أساسيًا لتطوير تطبيقات Python متقدمة وفعّالة. من خلال تطبيق هذه المفاهيم، يمكنك كتابة كود أكثر قابلية للصيانة وفعالية، وتحسين قدرتك على بناء تطبيقات قوية ومرنة باستخدام Python.

التحدي الذي تواجهه هنا هو كيفية تحسين كفاءة حساب أقصى حاصل ضرب لعدد من الأعداد في القائمة المعطاة. النهج الحالي يبدو واضحًا ولكنه غير فعال من حيث الوقت، حيث يحاول تجريب كل التركيبات الممكنة للأعداد في القائمة.

لزيادة الكفاءة، يمكننا استخدام نهجٍ أكثر ذكاءً. يمكننا أن نلاحظ أن أقصى حاصل ضرب يمكن أن ينتج من الأعداد الإيجابية والسالبة في القائمة، وأن حاصل الضرب سيكون إما الناتج من جميع الأعداد الإيجابية أو الأعداد السالبة، أو جميع الأعداد الإيجابية ما عدا واحدة فقط من الأعداد السالبة.

لذلك، يمكننا تحسين الأداء بشكل كبير عن طريق الحساب المباشر لهذه الحالات دون الحاجة إلى استخدام itertools لتجربة كل التركيبات. سأقدم لك دالة محسنة تقوم بذلك:

pythonCopy code
def max_product(xs):
    # ترتيب القائمة للعثور على الأعداد الإيجابية والسالبة
    positive_nums = sorted(x for x in xs if x > 0)
    negative_nums = sorted(x for x in xs if x < 0)

    # حساب أقصى حاصل ضرب
    max_product = float('-inf')

    # حالة 1: جميع الأعداد إيجابية
    if positive_nums:
        max_product = max(max_product, positive_nums[-1], 1)
    
    # حالة 2: جميع الأعداد سالبة
    if len(negative_nums) % 2 == 0:
        product = 1
        for num in negative_nums:
            product *= num
        max_product = max(max_product, product)

    # حالة 3: جميع الأعداد إيجابية ما عدا واحدة فقط من الأعداد السالبة
    if len(negative_nums) > 1:
        product = 1
        for num in positive_nums:
            product *= num
        product //= negative_nums[0]
        max_product = max(max_product, product)

    return max_product

# استخدام الدالة
nums = [1, 2, 3, -4, -5]
print(max_product(nums))  # النتيجة المتوقعة هي 60

هذه الدالة تعمل بشكل أكثر فعالية، حيث تنقسم العملية إلى حالات محددة بدلاً من تجربة كل التركيبات الممكنة، مما يقلل بشكل كبير من الوقت اللازم لحساب النتيجة النهائية.

بالطبع، إليك المقال المكتمل بعد إضافة المزيد من المعلومات:

تحسين كفاءة برمجية Python: أفضلية الأداء

في عالم البرمجة، يعتبر تحقيق الكفاءة والأداء الفعّال أمرًا حاسمًا، خاصة عندما يتعلق الأمر بمعالجة البيانات الضخمة أو العمليات الحسابية المعقدة. في هذا المقال، سنلقي نظرة على كيفية تحسين كفاءة الأداء في Python من خلال تحسين الخوارزميات والهياكل البيانية.

المشكلة

لنفترض أن لدينا قائمة تحتوي على مجموعة من الأعداد، ونرغب في حساب أقصى حاصل ضرب يمكن الحصول عليه من هذه الأعداد. تحديدًا، ستتكون القائمة من 1 إلى 50 عددًا في نطاق -1000 إلى 1000.

النهج الحالي

في البداية، دعونا نلقي نظرة على النهج الذي تم اتباعه في الحل الأصلي. تم استخدام حلقات تكرارية متداخلة لاستكشاف جميع التركيبات الممكنة للأعداد في القائمة باستخدام وحدة itertools في Python. هذا النهج، بالرغم من بساطته، يعاني من مشاكل في الأداء عندما يكون حجم البيانات كبيرًا.

الحل المحسن

لزيادة الكفاءة، يمكننا استخدام نهج أكثر ذكاءً. نحن ندرك أن أقصى حاصل ضرب يمكن الحصول عليه سيكون إما الناتج من جميع الأعداد الإيجابية أو السالبة في القائمة، أو من جميع الأعداد الإيجابية باستثناء واحدة فقط من الأعداد السالبة. بناءً على هذا الاستدلال، يمكننا كتابة دالة تقوم بحساب هذه الحالات بشكل مباشر بدلاً من تجربة كل التركيبات الممكنة.

pythonCopy code
def max_product(xs):
    # ترتيب القائمة للعثور على الأعداد الإيجابية والسالبة
    positive_nums = sorted(x for x in xs if x > 0)
    negative_nums = sorted(x for x in xs if x < 0)

    # حساب أقصى حاصل ضرب
    max_product = float('-inf')

    # حالة 1: جميع الأعداد إيجابية
    if positive_nums:
        max_product = max(max_product, positive_nums[-1], 1)
    
    # حالة 2: جميع الأعداد سالبة
    if len(negative_nums) % 2 == 0:
        product = 1
        for num in negative_nums:
            product *= num
        max_product = max(max_product, product)

    # حالة 3: جميع الأعداد إيجابية ما عدا واحدة فقط من الأعداد السالبة
    if len(negative_nums) > 1:
        product = 1
        for num in positive_nums:
            product *= num
        product //= negative_nums[0]
        max_product = max(max_product, product)

    return max_product

# استخدام الدالة
nums = [1, 2, 3, -4, -5]
print(max_product(nums))  # النتيجة المتوقعة هي 60

الختام

باستخدام النهج المحسن، يمكننا تحسين كفاءة الأداء بشكل كبير، وبالتالي تقليل الوقت اللازم لحساب النتيجة. عند التعامل مع بيانات كبيرة أو عمليات حسابية معقدة في Python، فإن تحسين كفاءة الأداء يمكن أن يكون حاسمًا لتحسين تجربة المستخدم وتقليل تكلفة الموارد.

عند النظر إلى الكود المعطى، نجد أن هناك فارقًا بين استخدام “return” و”raise” لرمي الاستثناءات. لنفهم الفارق بينهما، دعنا نلقي نظرة عميقة على كل منهما.

عندما تستخدم “return” في دالة، فإنك ببساطة ترجع قيمة معينة من الدالة وتنهي تنفيذها. في حالتنا هذه، الدالة f تستخدم “return” لإرجاع كائن استثناء Exception. ومع ذلك، يجب أن نلاحظ أن استخدام “return” بهذه الطريقة لا يتسبب في رفع استثناء بشكل فعلي. بدلاً من ذلك، يتم اعتبار الكائن الذي تم إرجاعه على أنه قيمة عادية تم إرجاعها من الدالة.

أما عند استخدام “raise”، فإنك تقوم برفع استثناء فعليًا. وفي حالتنا هذه، الدالة f تستخدم “raise” لرفع استثناء من نوع Exception. هذا يعني أنه عند استدعاء الدالة وحدوث الشرط المناسب، سيتم رفع الاستثناء وسيتم إيقاف التنفيذ في النقطة التي تم فيها رفع الاستثناء وسيتم نقل التنفيذ إلى بلوك الـ “except” المناسب.

لذا، الفارق الأساسي بين استخدام “return” و”raise” هو أن “return” تستخدم لإرجاع قيمة معينة من الدالة دون رفع استثناء، بينما “raise” تستخدم لرفع استثناء وإيقاف التنفيذ في حالة وجود حالة استثنائية.

الآن، بناءً على هذا الفارق، نستطيع توجيهك إلى متى يجب استخدام كل منهما. عندما تريد ببساطة إعلام المستخدم أو الكود الذي يستخدم الدالة بحدوث حالة خاصة أو خطأ، يمكنك استخدام “return” لإرجاع قيمة تدل على الخطأ دون رفع استثناء. أما عندما يتعين عليك إيقاف التنفيذ والتعامل بشكل فوري مع حالة خاصة، فيجب عليك استخدام “raise” لرفع استثناء والتحكم في سير التنفيذ.

باختصار، استخدم “return” لإرجاع قيمة تدل على حدوث حالة خاصة دون إيقاف التنفيذ، واستخدم “raise” لرفع استثناء والتحكم في سير التنفيذ عند حدوث حالة خاصة تستدعي ذلك.

إضافة إلى النقاط المذكورة أعلاه، يُلاحظ أن استخدام “return” لإرجاع قيمة تدل على حالة خاصة يمكن أن يكون طريقة فعّالة للتحكم في سير التنفيذ دون إيقافه تمامًا. فعلى سبيل المثال، يمكن للكود الذي يستدعي الدالة أن يحصل على القيمة المُرجعة من الدالة ويتخذ إجراءات مناسبة استنادًا إلى قيمتها، مثل طباعة رسالة تنبيه أو تنفيذ خطوات بديلة.

من ناحية أخرى، عند استخدام “raise”، يتم إيقاف التنفيذ فورًا ونقل التنفيذ إلى بلوك الـ “except” المناسب. هذا يعني أنه يمكن أن يكون لديك مراقبة دقيقة للأخطاء والاستثناءات وتنفيذ سير التنفيذ البديل بشكل محدد ومنظم.

على الرغم من الاختلاف في الاستخدام، يمكن لكل من “return” و”raise” أن يكونا ضروريين في كتابة الشفرة البرمجية الصلبة والموثوقة. فعلى سبيل المثال، يمكن استخدام “return” لفحص مدخلات المستخدم أو الشروط الأساسية للتحقق من صحتها دون إيقاف التنفيذ. بينما يمكن استخدام “raise” للتعامل مع حالات الخطأ الحرجة التي تتطلب تدخل فوري وإيقاف التنفيذ.

في النهاية، تعتمد القرارات بشأن استخدام “return” أو “raise” على طبيعة البرنامج ومتطلبات التنفيذ الخاصة به. عندما يكون لديك فهم واضح للفارق بينهما وللسياق البرمجي الذي تعمل فيه، ستكون قادرًا على اتخاذ القرارات الصحيحة بشأن أي منهما يجب استخدامه في الحالات المختلفة التي قد تواجهك في عملك كمبرمج.