تتمة لبعض الدوال في #set
7-الدالة #difference()
تعريفها
ترجع set جديد يحتوي على العناصر الموجودة في الـset الذي قام باستدعائها و الغير موجودة في كل #set نمرره لها مكان الباراميتر sets*.
بناؤها
set.difference(*sets)

8-الدالة #difference_update()
تعريفها
تستخدم هذه الدالة لحذف مجموعة عناصر من الـset الذي قام باستدعائها.
فعلياً, عند إستدعائها نمرر لها مكان الباراميتر *sets كائن set أو أكثر يحتوون على مجموعة العناصر التي نريد حذفها من الـset الذي قام باستدعائها في حال كانت موجودة فيها
بناؤها
set.difference_update(*sets)

======================
a={1,2,3,4,5,6,7,8}
b={1,3,5,7}
c={8,6}
print('a=',a)
print('a.difference(b,c)=',a.difference(b,c))
a.difference_update(b,c)
print('After a.difference_update(b,c)=',a)

تتمة لبعض الدوال في #set
9-الدالة #intersection()
تعريفها
ترجع set جديد يحتوي على العناصر الموجودة في الـset الذي قام باستدعائها و في كل set نمرره لها مكان الباراميتر sets*.

بناؤها
set.intersection(*sets)


10-الدالة #intersection_update()
تعريفها
تستخدم هذه الدالة لحذف مجموعة عناصر من الـ
set
 الذي قام باستدعائها.
فعلياً, عند إستدعائها نمرر لها مكان الباراميتر 
*sets
 كائن 
set
 أو أكثر يحتوون على مجموعة العناصر التي لا نريد أن يتم حذفها من الـ
set
 الذي قام باستدعائها في حال كانت موجودة فيه.

بناؤها
set.intersection_update(anotherSet)

#كود1 آلة حاسبة بسيطة:

انشاء دوال جمع وطرح وضرب وقسمة
def add(x, y):
    return x + y
def subtract(x, y):
    return x - y
def multiply(x,y):
    return x * y
def divide(x, y):
    return x / y

# طباعة قائمة الخيارات
print("Select operation")
print("1.Add")
print("2.Subtract")
print("3.Multiply")
print("4.Divide")

# اختيار العملية المطلوبة من المستخدم
choice = input('''Enter choice:
       1 for add
       2 for subtract
       3 for multiply
       4 for divide''')

num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

if choice == '1':
    print(num1,"+",num2,"=", add(num1,num2))

elif choice == '2':
    print(num1,"-",num2,"=", subtract(num1,num2))

elif choice == '3':
    print(num1,"*",num2,"=", multiply(num1,num2))

elif choice == '4':
    print(num1,"/",num2,"=", divide(num1,num2))
else:
    print("Invalid input")

#كود2 برنامج بسيط لحل معادلات من الدرجة الثانية
import cmath

a = float(input("Enter the coefficient of x^2: "))
b = float(input("Enter the coefficient of x: "))
c = float(input("Enter the constant term: "))

d = (b**2) - (4*a*c)

sol1 = (-b-cmath.sqrt(d))/(2*a)
sol2 = (-b+cmath.sqrt(d))/(2*a)

print('The solutions are {0} and {1}'.format(sol1,sol2))

#كود3   لإنشاء كلمات مرور عشوائية
--------------------------------
import random
import string

def generate_password(length):
letters = string.ascii_letters + string.digits + string.punctuation
return ''.join(random.choice(letters) for i in range(length))

print(generate_password(12)) # سيعيد البرنامج كلمة مرور عشوائية من 12 حرفًا
--------------------------------
يمكنك تغيير العدد الذي يمثل طول كلمة المرور بتغيير الرقم الموجود بالدالة الأخيرة "generate_password()" في الأمر الأخير.

#كود4 لإنشاء برنامج يمكنه التحويل بين وحدات الأطوال والحجوم والأوزان:
# تعريف دالة تحويل الأطوال
def convert_length(value, from_unit, to_unit):
    conversions = {
        "cm-m": 0.01,
        "m-cm": 100,
        "m-km": 0.001,
        "km-m": 1000,
        "km-ft": 3280.84,
        "ft-km": 0.0003048
    }
    return value * conversions[f"{from_unit}-{to_unit}"]

# تعريف دالة تحويل الحجوم
def convert_volume(value, from_unit, to_unit):
    conversions = {
        "ml-l": 0.001,
        "l-ml": 1000,
        "l-gal": 0.264172,
        "gal-l": 3.78541,
        "gal-pt": 8,
        "pt-gal": 0.125,
    }
    return value * conversions[f"{from_unit}-{to_unit}"]

# تعريف دالة تحويل الأوزان
def convert_weight(value, from_unit, to_unit):
    conversions = {
        "g-kg": 0.001,
        "kg-g": 1000,
        "kg-lbs": 2.20462,
        "lbs-kg": 0.453592,
        "lbs-oz": 16,
        "oz-lbs": 0.0625,
    }
    return value * conversions[f"{from_unit}-{to_unit}"]

# استدعاء دالة التحويل بين الأطوال
print(convert_length(1, "km", "ft"))  # تحويل 1 متر إلى قدم
print(convert_length(2, "km", "m"))  # تحويل 2 كيلومتر إلى متر

# استدعاء دالة التحويل بين الحجوم
print(convert_volume(500, "ml", "l"))  # تحويل 500 مل إلى لتر
print(convert_volume(1, "gal", "l"))  # تحويل 1 جالون إلى لتر

# استدعاء دالة التحويل بين الأوزان
print(convert_weight(1000, "g", "kg"))  # تحويل 1000 غرام إلى كيلوجرام
print(convert_weight(2.2, "lbs", "kg"))  # تحويل 2.2 باوند إلى كيلوجرام
يمكنك استخدام هذا الكود كنقطة انطلاق لتحويل الوحدات الأخرى. قم بإضافة دوال التحويل الخاصة بالوحدات التي تريد التحويل بينها، والتأكد من إضافة القيم المتقابلة لكل وحدة.

#كود5 برنامج يقوم بحساب تيار المحرك للمحركات أحادية الطور وثلاثية الطور وقطر السلك المناسب لتغذية المحرك بحيث ان يكون هبطو الجهد اقل من 5% بعد معرفة البيانات الأساسية للمحرك، وهي قدرة المحرك، وجهد التغذية، ومعامل الأداء، وكفاءة المحرك، والمسافة بين المحرك ومصدر التغذية، ونوع الكابل ونوع المحرك أحادي الطوراو ثلاثي الطور
------ ------- ----- ------ ------- ----- ------ ------- -----
import math
# البيانات الأساسية للمحرك
power = float(input("أدخل قدرة المحرك (بالكيلووات): "))
voltage = float(input("أدخل جهد التغذية (بالفولت): "))
power_factor = float(input("أدخل معامل الأداء: "))
efficiency = float(input("أدخل كفاءة المحرك: "))
distance = float(input("أدخل المسافة بين المحرك ومصدر التغذية (بالمتر): "))
cable_type = str(input("أدخل نوع الكابل (نحاسي / ألومنيومي): "))
motor_type = str(input("أدخل نوع المحرك (أحادي الطور / ثلاثي الطور): "))
# حساب تيار المحرك
if motor_type == "أحادي الطور":
current = (power * 1000) / (voltage * power_factor * efficiency)
print("تيار المحرك: ", round(current, 2), "أمبير")
# حساب قطر السلك المناسب
if cable_type == "نحاسي":
resistivity = 0.0178 # أوم / مم^2 / متر
elif cable_type == "ألومنيومي":
resistivity = 0.0283 # أوم / مم^2 / متر
else:
print("خطأ: نوع الكابل غير صحيح")
exit()
cable_area = (2 * current * distance * resistivity) / (voltage * 0.05)
cable_diameter = math.sqrt(cable_area / math.pi) * 2
print("قطر السلك المناسب: ", round(cable_diameter, 2), "مم")
elif motor_type == "ثلاثي الطور":
# الطريقة الأولى لحساب تيار المحرك
current = (power * 1000) / (1.732 * voltage * power_factor * efficiency)
print("تيار المحرك: ", round(current, 2), "أمبير")
# الطريقة الثانية لحساب تيار المحرك
# current = (power * 1000) / (voltage * power_factor * efficiency * 0.8)
# حساب قطر السلك المناسب
if cable_type == "نحاسي":
resistivity = 0.0178 # أوم / مم^2 / متر
elif cable_type == "ألومنيومي":
resistivity = 0.0283 # أوم / مم^2 / متر
else:
print("خطأ: نوع الكابل غير صحيح")
exit()
cable_area = (1.732 * current * distance * resistivity) / (voltage * 0.05)
cable_diameter = math.sqrt(cable_area / math.pi) * 2
print("قطر السلك المناسب: ", round(cable_diameter, 2), "مم")
else:
print("خطأ: نوع المحرك غير صحيح")
exit()

كل عام وانتم بخير

#كود6 بلغة البايثون لبرنامج مسابقات بحيث يكون عدة اسئلة مع التبديل العشوائي لترتيب الاسئلة في كل مرة يتم تشغيل البرنامج ولكل سؤال ٣ خيارات ايضا يتم التبديل بشكل عشوائي بترتيب خيارات الجواب و احدى هذه الخيارات يكون صح وفي حال اختار المستخدم الجواب الصح يزيد رصيده من النقاط ١٠ وفي حال اخطأ لايتم اضافة اي نقاط.
import random

questions = [
{
"question": "ما هي عاصمة السعودية؟",
"options": ["جدة", "الرياض", "الدمام"],
"answer": "الرياض"
},
{
"question": "ما هي عاصمة مصر؟",
"options": ["الجيزة", "الإسكندرية", "القاهرة"],
"answer": "القاهرة"
},
{
"question": "ما هو الحيوان الذي يطير؟",
"options": ["الحمام", "النسر", "الحصان"],
"answer": "النسر"
}
]

random.shuffle(questions)

score = 0

for question in questions:
print(question["question"])
random.shuffle(question["options"])
for i, option in enumerate(question["options"]):
print(f"{i+1}. {option}")
user_answer = input("اختر الجواب الصحيح (1-3): ")
if question["options"][int(user_answer)-1] == question["answer"]:
print("إجابة صحيحة!")
score += 10
else:
print("إجابة خاطئة!")

print(f"تم انهاء الاختبار، نقاطك: {score}")
-----------------------------

---- ---- ---- --- --- ---- ---- ---- --- ---
import random

# قائمة الأسئلة والإجابات الصحيحة والخيارات العشوائية
questions = ['ما هو عاصمة فرنسا؟', 'ما هي لغة البرمجة التي تستخدم في تطوير تطبيقات الأندرويد؟', 'ما هو لون الشعار الأساسي لشركة أبل؟']
correct_answers = ['باريس', 'جافا', 'رمادي']
options = [['لندن', 'باريس', 'برلين'], ['جافا', 'بيثون', 'سويفت'], ['أخضر', 'رمادي', 'أسود']]
score = 0

# تنسيق الأسئلة والخيارات
for i in range(len(questions)):
print(f'السؤال رقم {i + 1}: {questions[i]}')
random_options = random.sample(options[i], len(options[i]))
for j in range(len(random_options)):
print(f'{j + 1}. {random_options[j]}')
user_answer = int(input('اختر الإجابة الصحيحة (1-3): '))
if random_options[user_answer - 1] == correct_answers[i]:
score += 10 # إذا كانت الإجابة صحيحة، زيد الرصيد بمقدار 10 نقاط
print('إجابة صحيحة!')
else:
print('إجابة خاطئة :(')

print(f'لقد انتهت المسابقة، شكراً على المشاركة :) \nرصيدك النهائي هو {score} نقطة.') # عرض الرصيد النهائي للمستخدم

#كود7 لعبة التخمين يختار فيه الكمبيوتر رقمًا عشوائيًا. ثم يحصل المستخدمون على تلميح لتخمين الرقم. في كل مرة يخمن فيها اللاعبون الرقم الخطأ ، تنخفض درجاتهم ويصبح بإمكانهم اختيار دليل آخر. سيحتاجون إلى وظائف لمقارنة الرقم المُدخَل مع الرقم المُخمن لحساب الفرق بين الاثنين ، ثم التحقق مما إذا كان يمكن استخدام الرقم في مشروع بايثون أم لا.
----------------------------------------

import random

def play_game():
computer_choice = random.randint(1, 100)
attempts = 0
points = 100

while True:
user_choice = int(input("Enter a number between 1 and 100: "))
difference = abs(user_choice - computer_choice)

if difference == 0:
print("Congratulations! You guessed the number in", attempts, "attempts.")
return points
else:
print("Incorrect guess. Try again.")

if difference <= 10:
print("Hint: You're very close!")
elif difference <= 20:
print("Hint: You're getting closer!")
else:
print("Hint: You're far away from the number.")

points -= 10

if attempts == 5:
print("You've used all your attempts. The number was", computer_choice)
return 0

attempts += 1

print("Welcome to the number guessing game!")
name = input("Please enter your name: ")
print("Hello", name, "let's begin the game.")
score = play_game()
print("Your score is", score)

ماهية صيغة #f_string في لغة البرمجة بايثون.؟
f-string هي اختصار لـ "formatted string literals"
وهي طريقة جديدة لإنشاء سلاسل نصية (strings) مُهيأة (formatted) في Python 3.6 وما بعدها.
تعمل f-strings عن طريق إضافة حرف f قبل السلسلة النصية (string)، مثل هذا المثال:
name = "John"
age = 30
message = f"My name is {name} and I'm {age} years old."
print(message)

سينتج عن هذا المثال السطر التالي:
My name is John and I'm 30 years old.

في هذا المثال، تم إنشاء سلسلة نصية (string) وإضافة قيمتين مهيأتين (formatted) داخلها باستخدام الأقواس المتكونة من فتحية وغلقية ({}) مع وضع القيم الخاصة بهما داخلهما، وذلك باستخدام الـ f-strings.
يمكن أيضًا استخدام الـ f-strings مع التعابير الرياضية والدوال، على سبيل المثال:
num1 = 10
num2 = 20
result = f"The sum of {num1} and {num2} is {num1 + num2}."
print(result)

سينتج عن هذا المثال السطر التالي:
The sum of 10 and 20 is 30.

وكما ترى، فإن f-strings تسهل كتابة السلاسل النصية المُهيأة وتجعل الشفافية والوضوح أسهل عند عملية القراءة والصيانة.

هناك عدة أنماط يمكن استخدامها مع f-strings، وفيما يلي بعض الأمثلة:

1- تمرير متغيرات داخل الأقواس المتكونة من فتحية وغلقية:

name = "John"
age = 30
message = f"My name is {name.upper()} and I'm {age*2} years old."
print(message)
النتيجة:

My name is JOHN and I'm 60 years old.
2- تمرير قيم ثابتة داخل الأقواس المتكونة من فتحية وغلقية:

message = f"5 multiplied by 5 is {5*5}"
print(message)
النتيجة:

5 multiplied by 5 is 25
3- تمرير متغيرات مع إضافة قيم افتراضية في حال عدم وجودها:

name = "John"
message = f"Hello, {name}! Your balance is {1000.50:.2f}."
print(message)
النتيجة:

Hello, John! Your balance is 1000.50.
في هذا المثال، تم تحديد أن يتم عرض الرقم العشري بدقتين فقط (:.2f)، وكما ترى تم إضافة رقم افتراضي للرصيد في حال عدم وجوده.
4- تمرير تعابير شرطية داخل الأقواس المتكونة من فتحية وغلقية:

number = 10
message = f"The number is {'even' if number%2 == 0 else 'odd'}."
print(message)
النتيجة:

The number is even.
وفي هذا المثال، تم استخدام تعبير شرطي لتحديد نوع العدد (زوجي/فردي) وإظهاره داخل السلسلة النصية.
وهكذا، يمكن استخدام عدة أنماط لتكوين f-strings في بايثون، وذلك بحسب الحاجة والغرض المطلوب.

#كود8 بلغة البايثون وظيفته حل المعادلات الرياضية التفاضلية
يمكن استخدام بايثون لحل المعادلات التفاضلية باستخدام مكتبة scipy. هناك العديد من الطرق المختلفة للتعامل مع هذه المشكلة، ولكن هنا سنستخدم دالة solve_ivp التي تسمح بحل المعادلات التفاضلية بطريقة رقمية. لحل مثال بسيط، سنقوم بحل معادلة التفاضل الأولى y' = -2y مع الشرط الابتدائي y(0) = 1. يمكن القول أن هذه المعادلة تمثل نمو البكتيريا، حيث تنخفض بسرعة مع مرور الوقت. في البداية، نحتاج إلى استيراد المكتبة وتعريف المعادلة:
import numpy as np
from scipy.integrate import solve_ivp

def equation(t, y):
return -2*y
تعريف المعادلة يتم باستخدام دالة تأخذ متغيرات t و y وترجع قيمة الإشارة المشتقة في الوقت t والإشارة في الوقت t معًا. ثم، يتم تعريف الشروط الابتدائية للتفاضل الأولي:
t0, tmax = 0, 10
y0 = [1]
أي أننا نريد حل المعادلة في الفترة من الزمن 0 إلى 10، والشرط الابتدائي y(0) = 1. وأخيراً، يتم حل المعادلة باستخدام الدالة solve_ivp:
sol = solve_ivp(equation, (t0, tmax), y0)
تم حفظ الحل في sol. لرسم النتائج، يمكن استخدام الأمر التالي:
from matplotlib import pyplot as plt

plt.plot(sol.t, sol.y[0])
plt.xlabel('Time')
plt.ylabel('y')

اللهم احفظ عبادك المستضعفين وانصرهم على عدوهم
لاتنسو اخوانكم من الدعاء

المتغيرات وأنواع البيانات (Variables & Data Types)
في البرمجة، المتغير (Variable) هو عبارة عن "صندوق" أو مخزن في ذاكرة الكمبيوتر، نعطيه اسماً ونحفظ داخله قيمة معينة لنستخدمها أو نعدلها لاحقاً.

في بايثون، عندما نضع نصاً، يجب أن يكون بين علامات تنصيص "..." أو '...' ليعرف الكمبيوتر أنه نص عادي وليس أمراً برمجياً. أما الأرقام فنكتبها كما هي.

إليك أهم 3 أنواع بيانات ستحتاجها دائماً في بناء الواجهات الخلفية (Back-end):

1- النصوص (String / str): مثل الأسماء، العناوين، أو الرسائل.
2- الأعداد الصحيحة (Integer / int): أرقام بدون فاصلة عشرية (مثل العدادات، المعرفات IDs).
3- الأعداد العشرية (Float / float): أرقام بفاصلة عشرية (مثل الأسعار، المقاسات، أو النسب).

تطبيق عملي: كتابة الكود الأول
قم بفتح ملفك في PyCharm، :

python
# 1. تعريف المتغيرات وتخزين البيانات
item_name = "مخرطة حديد CNC"  # نص (String)
quantity = 3                  # عدد صحيح (Integer)
unit_price = 1450.50          # عدد عشري (Float)

# 2. حساب الإجمالي (عملية حسابية بسيطة)
total_cost = quantity * unit_price

# 3. طباعة النتائج في الـ Console
print("--- تفاصيل الطلبية ---")
print("المادة:", item_name)
print("الكمية المطلوب توريدها:", quantity)
print("إجمالي التكلفة بالدولار:", total_cost)

ملاحظة: الرمز # يُستخدم لكتابة "التعليقات" (Comments). أي سطر يبدأ بـ # يتجاهله الكمبيوتر تماماً ولا يشغله، وهو مخصص فقط لك لكي تكتب ملاحظات تشرح كودك لنفسك أو للمبرمجين الآخرين.

استقبال مدخلات المستخدم (User Input)
في بايثون، نستخدم دالة تُدعى input() لاستقبال البيانات من لوحة المفاتيح.

لكن هناك قاعدة مهمة جداً في بايثون: أي شيء يدخل عبر input() يعامله الكمبيوتر كنص (String) تلقائياً.
إذا أردنا إجراء عمليات حسابية على المدخلات (مثل الضرب أو الجمع)، يجب أن نُخبر بايثون بتحويل هذا النص إلى رقم باستخدام int() للأعداد الصحيحة، أو float() للأعداد العشرية. هذا المفهوم يسمى تحويل أنواع البيانات (Type Casting).

تطبيق عملي: تحديث البرنامج ليكون تفاعلياً:

# استقبال اسم الآلة كنص عادي
machine_type = input("أدخل نوع الآلة المطلوبة: ")

# استقبال الكمية وتحويلها فوراً إلى عدد صحيح (Integer)
input_qty = input("أدخل الكمية المطلوبة: ")
quantity = int(input_qty)

# استقبال السعر وتحويله إلى عدد عشري (Float)
input_price = input("أدخل سعر القطعة الواحدة: ")
price = float(input_price)

# حساب الإجمالي
total = quantity * price

# طباعة الفاتورة النهائية
print("\n--- فاتورة العرض الافتراضي ---")
print("المنتج:", machine_type)
print("الكمية المعتمدة:", quantity)
print("إجمالي القيمة:", total)

اتخاذ القرارات - الجمل الشرطية (If Statements)
في تطوير الـ Back-end، ستواجه دائماً مواقف تحتاج فيها لاتخاذ قرار؛ مثل: (إذا كان رمز المرور صحيحاً، اسمح للمستخدم بالدخول، وإلا اظهر له رسالة خطأ).

في بايثون، نستخدم الكلمات المفتاحية التالية لتوجيه البرنامج:

if (إذا): لفحص شرط معين، إذا كان صحيحاً ينفذ الكود التابع له.

elif (أو إذا): اختصار لـ (Else If)، نستخدمها إذا لم يتحقق الشرط الأول وأردنا فحص شرط آخر بديل.

else (والإلا): الخيار الأخير الذي ينفذ إذا فشلت جميع الشروط السابقة.
قاعدة ذهبية في بايثون: المسافات البادئة (Indentation)
بايثون لا تستخدم الأقواس { } لتحديد الكود التابع للشرط مثل بقية اللغات، بل تعتمد كلياً على المسافة البادئة (عادةً 4 مسافات أو ضغطة زر Tab).

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

تطبيق عملي: إضافة نظام خصومات ذكي لشركتك
لنطور كود الفاتورة السابق. نريد من البرنامج أن يفحص إجمالي الفاتورة:
إذا كان الإجمالي أكبر من أو يساوي 5000 دولار، يحصل العميل على خصم 10%.
إذا كان الإجمالي أكبر من أو يساوي 2000 دولار، يحصل على خصم 5%.
غير ذلك، لا يوجد خصم.

# مدخلات البرنامج
total_price = float(input("أدخل إجمالي قيمة الفاتورة الحالية بالدولار: "))

# فحص الشروط وتحديد نسبة الخصم
if total_price >= 5000:
    discount_percent = 10
    print("تهانينا! العميل يستحق خصم كبار العملاء (10%).")
elif total_price >= 2000:
    discount_percent = 5
    print("العميل يستحق الخصم القياسي (5%).")
else:
    discount_percent = 0
    print("المبلغ لا يؤهل للحصول على خصم.")

# حساب القيمة النهائية بعد الخصم
discount_amount = total_price * (discount_percent / 100)
final_price = total_price - discount_amount

# طباعة النتيجة النهائية
print("--- تقرير الحساب النهائي ---")
print("القيمة قبل الخصم:", total_price, "$")
print("قيمة الخصم المقتطع:", discount_amount, "$")
print("المبلغ المطلوب دفعه نهائياً:", final_price, "$")

حلقات التكرار (Loops)
في تطوير الـ Back-end، نلجأ كثيراً للتعامل مع مجموعات كبيرة من البيانات؛ مثل: قراءة قائمة تحتوي على 1000 منتج من قاعدة البيانات، أو إرسال بريد إلكتروني لـ 500 مشترك. من غير المنطقي كتابة الكود لكل عنصر بمفرده، وهنا يأتي دور حلقات التكرار (Loops) لتنفيذ نفس الكود عدة مرات تلقائياً وبأسطر معدودة.

في بايثون، لدينا نوعان أساسيان من حلقات التكرار:

1. الحلقة for تكرار بعدد محدد
نستخدم for عندما نعرف مسبقاً عدد المرات التي نريد تكرار الكود فيها، أو عندما نريد المرور على عناصر قائمة معينة.

نستخدم معها غالباً دالة تُدعى range(start, end)، وهي تولد لنا سلسلة من الأرقام تبدأ من الرقم الأول وتنتهي قبل الرقم الأخير بخطوة.

تطبيق عملي في :
اكتب هذا الكود لتجربة تكرار فحص الآلات في خط إنتاج:

# تكرار الكود 5 مرات (من 1 إلى 5)
print("بدء عملية الفحص الدوري للآلات:")

for count in range(1, 6):
    print("جاري فحص الآلة رقم:", count)

print("اكتمل فحص جميع الآلات بنجاح.")

2. الحلقة while تكرار بناءً على شرط
نستخدم while عندما لا نعرف كم مرة سيتكرر الكود، ولكننا نريد استمرار التكرار طالما أن هناك شرطاً معيناً لا يزال صحيحاً (True). بمجرد أن يصبح الشرط خاطئاً (False)، تتوقف الحلقة فوراً.

هذا المفهوم هو الأساس الذي تعمل به السيرفرات (تظل تعمل وتنتظر طلبات المستخدمين ولا تتوقف إلا إذا أطفأنا السيرفر).

تطبيق عملي في PyCharm:
لنصنع برنامجاً يطلب كلمة مرور، ولا يسمح للمستخدم بالمرور ويفك القفل إلا إذا كتب الكلمة الصحيحة (مثلاً: 1234):

# تعيين كلمة المرور الصحيحة
correct_password = "1234"

# استقبال المحاولة الأولى من المستخدم
user_input = input("الرجاء إدخال رمز المرور للدخول إلى النظام: ")

# استمرار التكرار طالما أن المدخل غير صحيح
while user_input != correct_password:
    print("❌ رمز المرور خاطئ! تم رفض الدخول.")
    # نطلب الإدخال مجدداً داخل الحلقة حتى نمنحه فرصة أخرى، وإلا ستستمر الحلقة للأبد
    user_input = input("حاول مرة أخرى: ")

# هذا السطر خارج الحلقة، لن يصل إليه البرنامج إلا إذا كُسر الشرط وأصبح المدخل صحيحاً
print("🔓 تم التحقق بنجاح. مرحباً بك في لوحة التحكم!")