عمليات مدهشة توفرها مكتبات بايثون المدمجة

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

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

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

قراءة الملفات وضغطها باستخدام gzip و zipfile

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

مكتبة gzip

تُستخدم للتعامل مع ملفات .gz، وهي ملفات مضغوطة باستخدام خوارزمية GZIP. يمكنك استخدامها لقراءة أو كتابة الملفات المضغوطة بسهولة، كما في المثال التالي:

import gzip

# كتابة ملف مضغوط
with gzip.open("example.txt.gz", "wt") as f:
    f.write("هذا نص مضغوط باستخدام gzip")

# قراءة الملف المضغوط
with gzip.open("example.txt.gz", "rt") as f:
    content = f.read()
    print(content)

مكتبة zipfile

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

import zipfile

# إنشاء ملف zip يحتوي على ملفات متعددة
with zipfile.ZipFile("archive.zip", "w") as archive:
    archive.write("file1.txt")
    archive.write("file2.txt")

# استخراج الملفات من الأرشيف
with zipfile.ZipFile("archive.zip", "r") as archive:
    archive.extractall("output_folder")

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

اكتشاف ملفات النظام والمجلدات باستخدام os و pathlib

بايثون توفر أدوات قوية للتعامل مع نظام الملفات من خلال مكتبتين أساسيتين: os القديمة والموثوقة، وpathlib الحديثة والأكثر مرونة. يمكن استخدامهما لإنشاء مجلدات، حذفها، التنقل بين المجلدات، قراءة أسماء الملفات، واختبار وجود الملفات أو نوعها.

باستخدام os

import os

# الحصول على الملفات في مجلد معين
files = os.listdir(".")
print(files)

# التأكد إذا ما كان المسار هو ملف
print(os.path.isfile("script.py"))

# إنشاء مجلد جديد
if not os.path.exists("new_folder"):
    os.mkdir("new_folder")

باستخدام pathlib

pathlib توفر واجهة كائنية أكثر وضوحًا وحداثة:

from pathlib import Path

# تحديد مجلد العمل الحالي
current_dir = Path(".")

# استعراض الملفات فقط داخل المجلد
files = [f for f in current_dir.iterdir() if f.is_file()]
print(files)

# إنشاء مجلد جديد
new_folder = current_dir / "new_folder"
new_folder.mkdir(exist_ok=True)

pathlib تجعل كتابة الشيفرة أكثر نظافة وتقلل الاعتماد على السلاسل النصية لمسارات الملفات. كما تدعم الجمع بين المسارات باستخدام / بدلاً من دوال os.path.join القديمة.

توليد أرقام عشوائية متقدمة باستخدام random و secrets

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

• random: مناسبة للألعاب والمحاكاة.

• secrets: مصممة لتوليد بيانات حساسة وآمنة، مثل كلمات المرور أو الرموز.

استخدام random

import random

# عدد عشـوائي بين رقمين
print(random.randint(1, 100))

# اختيار عنصر عشـوائي من قائمة
print(random.choice(["apple", "banana", "cherry"]))

# ترتيب عشوائي لعناصر قائمة
items = [1, 2, 3, 4, 5]
random.shuffle(items)
print(items)

# توليد عدد عشـوائي بين 0 و 1
print(random.random())

استخدام secrets لتوليد بيانات أكثر أمانًا

import secrets

# توليد عدد عشـوائي آمن بين 0 و 99
print(secrets.randbelow(100))

# اختيار عنصر بشكل غير قابل للتنبؤ
print(secrets.choice(["red", "green", "blue"]))

# توليد رمز عشـوائي يصلح لكلمات المرور
print(secrets.token_hex(16))  # 32 رقم/حرف عشـوائي

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

تنسيق الوقت والتاريخ بدقة باستخدام datetime و calendar

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

مكتبة datetime

from datetime import datetime, timedelta

# الوقت والتاريخ الحالي
now = datetime.now()
print(now)

# تنسيق التاريخ
print(now.strftime("%Y-%m-%d %H:%M:%S"))

# إضافة أو طرح أيام
yesterday = now - timedelta(days=1)
print("أمس:", yesterday)

# تحويل سلسلة نصية إلى كائن datetime
dt = datetime.strptime("2025-07-04", "%Y-%m-%d")
print(dt)

مكتبة calendar

import calendar

# عرض تقويم شهر معين
print(calendar.month(2025, 7))

# معرفة إذا كانت السنة كبيسة
print(calendar.isleap(2024))  # True

# عدد الأيام في شهر معين
print(calendar.monthrange(2025, 7))  # (0, 31) => يبدأ بيوم الأحد، وعدد الأيام 31

المكتبتان معًا تغطيان كل ما يحتاجه المبرمج من حسابات زمنية، معالجة الفوارق بين التواريخ، توليد تقاويم، أو دعم مناطق زمنية (مع إضافات اختيارية مثل pytz عند الحاجة لاحقًا).

إجراء العمليات الرياضية المتقدمة باستخدام math و decimal

عند العمل مع الحسابات الرياضية الدقيقة أو المعقدة، توفر بايثون مكتبتين مدمجتين تساعدان على ذلك: math للعمليات الرياضية الأساسية والثوابت، وdecimal للدقة العالية في الأرقام العشرية التي تتطلب نتائج دقيقة مثل التعاملات المالية.

استخدام math

import math

# الجذر التربيعي
print(math.sqrt(25))

# الجيب وجيب التمام
print(math.sin(math.pi / 2))  # = 1.0
print(math.cos(0))            # = 1.0

# اللوغاريتم الطبيعي
print(math.log(10))

# التقريب للأعلى أو الأسفل
print(math.ceil(4.2))  # = 5
print(math.floor(4.8)) # = 4

# الثوابت الرياضية
print(math.pi)    # 3.14159...
print(math.e)     # 2.71828...

استخدام decimal لحسابات عشرية دقيقة

from decimal import Decimal, getcontext

# تغيير دقة الأرقام العشرية
getcontext().prec = 6

# عمليات حسابية دقيقة
a = Decimal("1.10")
b = Decimal("2.20")
c = a + b
print(c)  # 3.30 بدون أخطاء التقريب الموجودة في float

# مقارنة مع float
print(1.10 + 2.20)  # 3.3000000000000003

مكتبة decimal مفيدة جدًا عند الحاجة لنتائج خالية من أخطاء التقريب العائمة (floating-point errors) التي تحدث مع float. وهي شائعة في البرامج المالية أو التي تتطلب دقة عالية في النقاط العشرية.

تحليل البيانات النصية باستخدام re للعبارات النمطية

مكتبة re المدمجة في بايثون تتيح البحث داخل النصوص وتحليلها بدقة باستخدام العبارات النمطية (Regular Expressions)، وهي أداة لا غنى عنها لتنظيف البيانات، التحقق من الصيغ، واستخلاص الأنماط من السلاسل النصية.

البحث داخل نص

import re

text = "البريد الإلكتروني هو [email protected]"
match = re.search(r"\w+@\w+\.\w+", text)

if match:
    print("تم العثور على بريد إلكتروني:", match.group())

استخراج كل العناصر المطابقة

text = "الأرقام في النص هي: 42 و 99 و 123"
numbers = re.findall(r"\d+", text)
print(numbers)  # ['42', '99', '123']

التحقق من صيغة بيانات

phone = "771234567"
if re.fullmatch(r"\d{9}", phone):
    print("رقم هاتف صحيح")

الاستبدال والتعديل داخل النصوص

text = "مرحبًا بك في الموقع القديم: http://oldsite.com"
updated = re.sub(r"http://\w+\.\w+", "https://newsite.com", text)
print(updated)

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

استخدام collections للحصول على تراكيب بيانات محسّنة

المكتبة المدمجة collections في بايثون توفر هياكل بيانات إضافية وفعالة لا تتوفر في الأنواع التقليدية مثل list و dict. هذه الهياكل تحل الكثير من المشكلات الشائعة بطريقة أكثر مرونة وسهولة.

Counter لعدّ العناصر

from collections import Counter

data = ["apple", "banana", "apple", "orange", "banana", "apple"]
counts = Counter(data)
print(counts)
# الناتج: Counter({'apple': 3, 'banana': 2, 'orange': 1})

Counter مثالية لتحليل التكرار في البيانات، مثل عد الكلمات أو العناصر.

defaultdict لتفادي الأخطاء مع المفاتيح غير الموجودة

from collections import defaultdict

d = defaultdict(int)
d["a"] += 1
d["b"] += 2
print(d)

بعكس القاموس العادي، defaultdict ينشئ القيمة الابتدائية تلقائيًا (مثل 0 أو قائمة أو مجموعة) مما يمنع حدوث KeyError.

namedtuple لإنشاء كائنات تشبه الكلاسات

from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
print(p.x, p.y)

namedtuple يوفر طريقة خفيفة وسريعة لتعريف هياكل بيانات قابلة للقراءة، تشبه الكائنات لكن دون كلفة الأداء المرتبطة بالكلاسات.

deque لقوائم مزدوجة النهاية (أداء أعلى من list)

from collections import deque

dq = deque([1, 2, 3])
dq.appendleft(0)
dq.append(4)
print(dq)  # deque([0, 1, 2, 3, 4])
dq.pop()
dq.popleft()
print(dq)  # deque([1, 2, 3])

deque مصممة لعمليات الإضافة والحذف السريعة من الطرفين، وتتفوق على list في الأداء في هذه الحالات.

التعامل مع الأحداث المتزامنة باستخدام threading و asyncio

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

• threading للتنفيذ متعدد الخيوط (Multi-threading)

• asyncio للبرمجة غير المتزامنة (Asynchronous programming)

استخدام threading لتشغيل مهام متوازية

import threading
import time

def task(name):
    print(f"بدأ {name}")
    time.sleep(2)
    print(f"انتهى {name}")

t1 = threading.Thread(target=task, args=("المهمة 1",))
t2 = threading.Thread(target=task, args=("المهمة 2",))

t1.start()
t2.start()

t1.join()
t2.join()

threading مفيد عندما تحتاج إلى تشغيل وظائف متعددة لا تعتمد على بعضها وتستفيد من وقت الانتظار (مثل انتظار الشبكة).

استخدام asyncio لبرمجة غير متزامنة

import asyncio

async def task(name):
    print(f"بدأ {name}")
    await asyncio.sleep(2)
    print(f"انتهى {name}")

async def main():
    await asyncio.gather(
        task("المهمة A"),
        task("المهمة B")
    )

asyncio.run(main())

asyncio يسمح بكتابة كود متزامن بطريقة تبدو متسلسلة، مما يجعله مثاليًا في التطبيقات التي تتعامل مع الكثير من الانتظار (مثل واجهات برمجة التطبيقات، قواعد البيانات، الشبكة).

الفرق الرئيسي أن threading يشغل عدة خيوط فعلية، بينما asyncio يدير تدفق التنفيذ داخل خيط واحد بطريقة غير متزامنة باستخدام await.

جمع وتحليل بيانات الأداء باستخدام timeit و cProfile

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

استخدام timeit لقياس وقت تنفيذ كود بسيط

import timeit

code = "sum(range(1000))"
duration = timeit.timeit(code, number=1000)
print("المدة:", duration)

يمكنك من خلال timeit مقارنة طريقتين مختلفتين لتحقيق نفس الغرض ومعرفة أيهما أسرع.

استخدام cProfile لتحليل الأداء الكامل

import cProfile

def slow_function():
    total = 0
    for i in range(10000):
        total += sum(range(i))
    return total

cProfile.run("slow_function()")

cProfile يعرض عدد المرات التي تم فيها استدعاء كل دالة، والوقت الذي استغرقته، مما يساعدك على معرفة نقاط الضعف في الأداء.

استخدام time لمراقبة الكود يدويًا

في بعض الحالات يمكن استخدام time لمراقبة أجزاء محددة يدويًا:

import time

start = time.time()
# كود بطيء هنا
time.sleep(1)
end = time.time()

print("المدة:", end - start)

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

التعامل مع الكائنات المؤقتة والأنظمة الخارجية باستخدام shutil و os

عند تنفيذ مهام تتعلق بإدارة الملفات على مستوى النظام، مثل نسخ المجلدات، حذف الملفات، أو نقلها، فإن مكتبة shutil بالتعاون مع os تمنحك واجهات قوية وآمنة للتعامل مع هذه العمليات.

نسخ الملفات والمجلدات باستخدام shutil

import shutil

# نسخ ملف
shutil.copy("source.txt", "copy.txt")

# نسخ مجلد كامل (بما فيه من ملفات ومجلدات فرعية)
shutil.copytree("original_folder", "backup_folder")

# حذف مجلد ومحتوياته
shutil.rmtree("backup_folder")

نقل الملفات

shutil.move("file.txt", "folder/file.txt")

إنشاء وحذف الملفات والمجلدات باستخدام os

import os

# إنشاء مجلد
os.mkdir("new_dir")

# التحقق من وجود ملف
if os.path.exists("file.txt"):
    os.remove("file.txt")

shutil تُستخدم كثيرًا في أدوات النسخ الاحتياطي، البرمجيات التي تنظم الملفات تلقائيًا، أو أي سكريبت يتعامل مع النظام بشكل مباشر.

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

تحميل البيانات من الإنترنت باستخدام urllib.request

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

تحميل صفحة HTML أو JSON

import urllib.request

url = "https://httpbin.org/json"
response = urllib.request.urlopen(url)
data = response.read().decode("utf-8")

print(data)

تحميل ملف وتخزينه محليًا

url = "https://example.com/file.zip"
urllib.request.urlretrieve(url, "downloaded_file.zip")

إرسال طلب GET مع رؤوس مخصصة

from urllib.request import Request, urlopen

req = Request("https://httpbin.org/get", headers={"User-Agent": "Mozilla/5.0"})
with urlopen(req) as res:
    print(res.read().decode())

معالجة الأخطاء المحتملة

from urllib.error import URLError, HTTPError

try:
    urllib.request.urlopen("https://example.com/notfound")
except HTTPError as e:
    print("خطأ HTTP:", e.code)
except URLError as e:
    print("مشكلة في الاتصال:", e.reason)

urllib.request تمنحك التحكم الكامل في الاتصال بالويب، وهي كافية لأغلب العمليات البسيطة مثل تحميل الملفات أو قراءة البيانات من API، بدون الحاجة لمكتبات ثقيلة مثل requests إذا لم تكن مثبتة.

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

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

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