أنواع البيانات في بايثون (Python Data Types)

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

1. لماذا نحتاج لأنواع بيانات مختلفة؟

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

  • الأرقام: تحتاج لإجراء عمليات حسابية عليها (جمع، طرح، ضرب، إلخ)
  • النصوص: تحتاج لعمليات نصية (دمج، تقسيم، بحث، إلخ)
  • القيم المنطقية: تحتاجها للشروط والقرارات (صح أو خطأ)
  • القوائم: تحتاجها لتخزين مجموعات من القيم المرتبة

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

2. الأرقام الصحيحة (Integer - int)

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

integers.py
# أمثلة على الأرقام الصحيحة
age = 25
temperature = -10
zero = 0
big_number = 1000000000000000000000  # بايثون تتعامل مع أرقام ضخمة!

# طباعة القيم وأنواعها
print("العمر:", age, "- النوع:", type(age))
print("الحرارة:", temperature, "- النوع:", type(temperature))
print("الصفر:", zero, "- النوع:", type(zero))
print("رقم كبير:", big_number)

# العمليات الحسابية على الأرقام الصحيحة
x = 10
y = 3

print("\nالعمليات الحسابية:")
print(f"{x} + {y} = {x + y}")      # جمع
print(f"{x} - {y} = {x - y}")      # طرح
print(f"{x} * {y} = {x * y}")      # ضرب
print(f"{x} / {y} = {x / y}")      # قسمة (تعطي float)
print(f"{x} // {y} = {x // y}")    # قسمة صحيحة (تعطي int)
print(f"{x} % {y} = {x % y}")      # باقي القسمة
print(f"{x} ** {y} = {x ** y}")    # أس (رفع لقوة)
النتيجة
العمر: 25 - النوع: الحرارة: -10 - النوع: الصفر: 0 - النوع: رقم كبير: 1000000000000000000000 العمليات الحسابية: 10 + 3 = 13 10 - 3 = 7 10 * 3 = 30 10 / 3 = 3.3333333333333335 10 // 3 = 3 10 % 3 = 1 10 ** 3 = 1000

3. الأرقام العشرية (Float)

الأرقام العشرية (Floating-Point Numbers) هي الأرقام التي تحتوي على كسور عشرية. في بايثون، نوع البيانات للأرقام العشرية هو float. تُستخدم للقياسات الدقيقة، الحسابات العلمية، والأسعار.

floats.py
# أمثلة على الأرقام العشرية
pi = 3.14159
height = 1.75
price = 99.99
negative_float = -15.5

print("باي:", pi, "- النوع:", type(pi))
print("الطول:", height, "متر")
print("السعر:", price, "دولار")

# يمكنك استخدام الترميز العلمي
speed_of_light = 3e8  # 3 × 10^8
small_number = 1.5e-3  # 1.5 × 10^-3

print("\nالترميز العلمي:")
print("سرعة الضوء:", speed_of_light, "م/ث")
print("رقم صغير:", small_number)

# العمليات على الأرقام العشرية
a = 10.5
b = 2.5

print(f"\n{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")

# ملاحظة: القسمة العادية تعطي دائماً float
result = 10 / 2
print(f"\n10 / 2 = {result} (النوع: {type(result)})")
النتيجة
باي: 3.14159 - النوع: الطول: 1.75 متر السعر: 99.99 دولار الترميز العلمي: سرعة الضوء: 300000000.0 م/ث رقم صغير: 0.0015 10.5 + 2.5 = 13.0 10.5 - 2.5 = 8.0 10.5 * 2.5 = 26.25 10.5 / 2.5 = 4.2 10 / 2 = 5.0 (النوع: )

4. النصوص (String - str)

النصوص (Strings) هي تسلسلات من الأحرف. في بايثون، نوع البيانات للنصوص هو str. النصوص تُحاط بعلامات تنصيص مفردة ' أو مزدوجة " أو ثلاثية ''' أو """.

strings.py
# طرق مختلفة لإنشاء النصوص
name1 = 'أحمد'              # علامات تنصيص مفردة
name2 = "محمد"              # علامات تنصيص مزدوجة
message = """هذا نص
متعدد الأسطر
يمكن أن يمتد على عدة أسطر"""

print("الاسم الأول:", name1, "- النوع:", type(name1))
print("الاسم الثاني:", name2)
print("\nالرسالة:")
print(message)

# دمج النصوص (Concatenation)
first_name = "أحمد"
last_name = "محمد"
full_name = first_name + " " + last_name
print("\nالاسم الكامل:", full_name)

# تكرار النصوص
separator = "=" * 40
print(separator)

# طول النص
text = "مرحباً بك في عالم بايثون"
print(f"طول النص: {len(text)} حرف")

# الوصول إلى أحرف محددة (Indexing)
word = "Python"
print(f"\nالكلمة: {word}")
print(f"الحرف الأول: {word[0]}")
print(f"الحرف الأخير: {word[-1]}")
print(f"الأحرف من 0 إلى 3: {word[0:3]}")

# عمليات نصية شائعة
text = "  Hello World  "
print(f"\nالنص الأصلي: '{text}'")
print(f"أحرف كبيرة: '{text.upper()}'")
print(f"أحرف صغيرة: '{text.lower()}'")
print(f"إزالة المسافات: '{text.strip()}'")
print(f"استبدال: '{text.replace('World', 'Python')}'")
print(f"يبدأ بـ Hello؟ {text.strip().startswith('Hello')}")
النتيجة
الاسم الأول: أحمد - النوع: الاسم الثاني: محمد الرسالة: هذا نص متعدد الأسطر يمكن أن يمتد على عدة أسطر الاسم الكامل: أحمد محمد ======================================== طول النص: 27 حرف الكلمة: Python الحرف الأول: P الحرف الأخير: n الأحرف من 0 إلى 3: Pyt النص الأصلي: ' Hello World ' أحرف كبيرة: ' HELLO WORLD ' أحرف صغيرة: ' hello world ' إزالة المسافات: 'Hello World' استبدال: ' Hello Python ' يبدأ بـ Hello؟ True

5. القيم المنطقية (Boolean - bool)

القيم المنطقية (Booleans) هي نوع بيانات يحتوي على قيمتين فقط: True (صحيح) أو False (خاطئ). تُستخدم بشكل أساسي في الشروط واتخاذ القرارات. في بايثون، نوع البيانات هو bool.

booleans.py
# القيم المنطقية
is_student = True
is_graduated = False

print("طالب؟", is_student, "- النوع:", type(is_student))
print("متخرج؟", is_graduated)

# القيم المنطقية من المقارنات
age = 20
is_adult = age >= 18
print(f"\nالعمر: {age}")
print(f"بالغ؟ {is_adult}")

# عمليات المقارنة تعطي قيماً منطقية
x = 10
y = 5

print(f"\n{x} > {y} = {x > y}")
print(f"{x} < {y} = {x < y}")
print(f"{x} == {y} = {x == y}")
print(f"{x} != {y} = {x != y}")
print(f"{x} >= {y} = {x >= y}")
print(f"{x} <= {y} = {x <= y}")

# العمليات المنطقية
has_ticket = True
has_id = True
can_enter = has_ticket and has_id

print(f"\nلديه تذكرة: {has_ticket}")
print(f"لديه هوية: {has_id}")
print(f"يمكنه الدخول: {can_enter}")

# القيم التي تُعتبر False في بايثون
print("\nالقيم التي تُعتبر False:")
print(f"bool(0) = {bool(0)}")
print(f"bool('') = {bool('')}")
print(f"bool(None) = {bool(None)}")
print(f"bool([]) = {bool([])}")

print("\nالقيم التي تُعتبر True:")
print(f"bool(1) = {bool(1)}")
print(f"bool('text') = {bool('text')}")
print(f"bool([1, 2]) = {bool([1, 2])}")
النتيجة
طالب؟ True - النوع: متخرج؟ False العمر: 20 بالغ؟ True 10 > 5 = True 10 < 5 = False 10 == 5 = False 10 != 5 = True 10 >= 5 = True 10 <= 5 = False لديه تذكرة: True لديه هوية: True يمكنه الدخول: True القيم التي تُعتبر False: bool(0) = False bool('') = False bool(None) = False bool([]) = False القيم التي تُعتبر True: bool(1) = True bool('text') = True bool([1, 2]) = True

6. أنواع البيانات المركبة (نظرة سريعة)

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

القوائم (Lists)

القوائم هي مجموعات مرتبة وقابلة للتعديل من العناصر:

lists_intro.py
# قائمة من الأرقام
numbers = [1, 2, 3, 4, 5]
print("الأرقام:", numbers, "- النوع:", type(numbers))

# قائمة من النصوص
names = ["أحمد", "محمد", "فاطمة"]
print("الأسماء:", names)

# قائمة مختلطة (أنواع مختلفة)
mixed = [25, "أحمد", 1.75, True]
print("قائمة مختلطة:", mixed)

# الوصول إلى العناصر
print(f"الاسم الأول: {names[0]}")
print(f"عدد الأسماء: {len(names)}")
النتيجة
الأرقام: [1, 2, 3, 4, 5] - النوع: الأسماء: ['أحمد', 'محمد', 'فاطمة'] قائمة مختلطة: [25, 'أحمد', 1.75, True] الاسم الأول: أحمد عدد الأسماء: 3
القواميس (Dictionaries)

القواميس تخزن البيانات على شكل أزواج مفتاح-قيمة:

dicts_intro.py
# قاموس معلومات طالب
student = {
    "name": "أحمد",
    "age": 20,
    "grade": 85.5,
    "is_active": True
}

print("الطالب:", student, "- النوع:", type(student))
print(f"الاسم: {student['name']}")
print(f"العمر: {student['age']}")
print(f"الدرجة: {student['grade']}")
النتيجة
الطالب: {'name': 'أحمد', 'age': 20, 'grade': 85.5, 'is_active': True} - النوع: الاسم: أحمد العمر: 20 الدرجة: 85.5

7. التحقق من نوع البيانات

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

type_checking.py
# استخدام type() لمعرفة النوع
x = 42
y = 3.14
z = "Hello"
w = True

print("نوع x:", type(x))
print("نوع y:", type(y))
print("نوع z:", type(z))
print("نوع w:", type(w))

# استخدام isinstance() للتحقق من النوع
age = 25

print(f"\nهل age من نوع int؟ {isinstance(age, int)}")
print(f"هل age من نوع float؟ {isinstance(age, float)}")
print(f"هل age من نوع str؟ {isinstance(age, str)}")

# مفيد في الشروط
if isinstance(age, int):
    print("العمر رقم صحيح ✓")
else:
    print("العمر ليس رقماً صحيحاً ✗")
النتيجة
نوع x: نوع y: نوع z: نوع w: هل age من نوع int؟ True هل age من نوع float؟ False هل age من نوع str؟ False العمر رقم صحيح ✓

8. مثال شامل: حاسبة متقدمة

لنجمع كل أنواع البيانات في مثال عملي:

advanced_calculator.py
"""
حاسبة متقدمة توضح استخدام أنواع البيانات المختلفة
"""

# معلومات المنتج (أنواع بيانات مختلفة)
product_name = "لابتوب Dell"           # str
base_price = 1000                      # int
discount_rate = 0.15                   # float
is_available = True                    # bool
stock_quantity = 25                    # int

# حساب السعر النهائي
discount_amount = base_price * discount_rate
final_price = base_price - discount_amount
tax_rate = 0.10
tax_amount = final_price * tax_rate
total_price = final_price + tax_amount

# عرض التقرير
print("=" * 60)
print(f"{'تقرير المنتج':^60}")
print("=" * 60)
print()

print(f"اسم المنتج: {product_name}")
print(f"نوع الاسم: {type(product_name).__name__}")
print()

print(f"السعر الأساسي: ${base_price}")
print(f"نوع السعر: {type(base_price).__name__}")
print()

print(f"نسبة الخصم: {discount_rate * 100}%")
print(f"نوع النسبة: {type(discount_rate).__name__}")
print(f"قيمة الخصم: ${discount_amount:.2f}")
print()

print(f"السعر بعد الخصم: ${final_price:.2f}")
print(f"الضريبة ({tax_rate * 100}%): ${tax_amount:.2f}")
print(f"السعر النهائي: ${total_price:.2f}")
print()

print(f"متوفر: {'نعم ✓' if is_available else 'لا ✗'}")
print(f"نوع التوفر: {type(is_available).__name__}")
print(f"الكمية المتوفرة: {stock_quantity} وحدة")
print()

# قائمة الميزات (list)
features = ["معالج i7", "16GB RAM", "512GB SSD", "شاشة 15.6 بوصة"]
print("الميزات:")
for i, feature in enumerate(features, 1):
    print(f"  {i}. {feature}")

print()
print("=" * 60)

# ملخص الأنواع المستخدمة
print("\nملخص أنواع البيانات المستخدمة:")
print(f"  - str (نص): {product_name}")
print(f"  - int (رقم صحيح): {base_price}, {stock_quantity}")
print(f"  - float (رقم عشري): {discount_rate}, {final_price:.2f}")
print(f"  - bool (منطقي): {is_available}")
print(f"  - list (قائمة): {len(features)} ميزات")
النتيجة
============================================================ تقرير المنتج ============================================================ اسم المنتج: لابتوب Dell نوع الاسم: str السعر الأساسي: $1000 نوع السعر: int نسبة الخصم: 15.0% نوع النسبة: float قيمة الخصم: $150.00 السعر بعد الخصم: $850.00 الضريبة (10.0%): $85.00 السعر النهائي: $935.00 متوفر: نعم ✓ نوع التوفر: bool الكمية المتوفرة: 25 وحدة الميزات: 1. معالج i7 2. 16GB RAM 3. 512GB SSD 4. شاشة 15.6 بوصة ============================================================ ملخص أنواع البيانات المستخدمة: - str (نص): لابتوب Dell - int (رقم صحيح): 1000, 25 - float (رقم عشري): 0.15, 850.00 - bool (منطقي): True - list (قائمة): 4 ميزات
💡 نقاط مهمة لتذكرها
  • int: للأرقام الصحيحة (بدون كسور عشرية)
  • float: للأرقام العشرية (بكسور عشرية)
  • str: للنصوص (محاطة بعلامات تنصيص)
  • bool: للقيم المنطقية (True أو False فقط)
  • استخدم type() لمعرفة نوع أي قيمة
  • استخدم isinstance() للتحقق من نوع محدد
  • بايثون لغة ديناميكية - النوع يُحدد تلقائياً من القيمة

الخطوة التالية

الآن بعد أن فهمت أنواع البيانات، تعلم كيفية التحويل بينها

الدرس التالي: التحويل بين أنواع البيانات
المحرر الذكي

اكتب الكود وشاهد النتيجة فوراً

جرب الآن مجاناً
قناة ديف عربي

تابع أحدث الدروس والتحديثات مباشرة على واتساب

انضم الآن