حساب وإنشاء عاملي والتباديل والتركيبات في بايثون

اعمال

يمكن استخدام وحدة الرياضيات القياسية للوظائف الرياضية في بايثون لحساب العوامل. لدى SciPy أيضًا وظائف لحساب العدد الإجمالي للتباديل / التوليفات.

يمكن أيضًا استخدام وحدة itertools لإنشاء التباديل والتوليفات من القوائم (المصفوفات) ، وما إلى ذلك ، وتعدادها.

يتم شرح ما يلي هنا ، جنبًا إلى جنب مع نموذج التعليمات البرمجية.

  • عاملي:math.factorial()
  • احسب العدد الإجمالي للتباديل
    • math.factorial()
    • scipy.special.perm()
  • توليد وتعداد التباديل من قائمة:itertools.permutations()
  • احسب العدد الإجمالي للتركيبات
    • math.factorial()
    • scipy.special.comb()
    • كيف لا تستخدم math.factorial ()
  • إنشاء وتعداد مجموعات من القوائم:itertools.combinations()
  • احسب العدد الإجمالي للمجموعات المكررة
  • إنشاء وتعداد مجموعات مكررة من قائمة:itertools.combinations_with_replacement()

كمثال على استخدام التباديل ، يتم أيضًا شرح ما يلي.

  • إنشاء الجناس الناقصة من السلاسل

إذا كنت ترغب في إنشاء مجموعة من عناصر القوائم المتعددة بدلاً من قائمة واحدة ، فاستخدم itertools.product () في وحدة itertools.

عاملي:math.factorial()

توفر الوحدة النمطية للرياضيات عاملاً دالة () يقوم بإرجاع العامل.

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

ستؤدي القيم السالبة غير الصحيحة إلى ValueError.

# print(math.factorial(1.5))
# ValueError: factorial() only accepts integral values

# print(math.factorial(-1))
# ValueError: factorial() not defined for negative values

احسب العدد الإجمالي للتباديل

math.factorial()

التبديلات هي عدد الحالات التي يتم فيها اختيار r من عدد n مختلف وتوضع في صف واحد.

يتم الحصول على العدد الإجمالي للتباديل ، p ، بالمعادلة التالية باستخدام العوامل.

p = n! / (n - r)!

يمكن حسابها على النحو التالي باستخدام دالة math.factorial () التي ترجع العامل. يتم استخدام عامل التشغيل ⌘ ، الذي ينفذ قسمة عدد صحيح ، لإرجاع نوع عدد صحيح.

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

print(permutations_count(4, 2))
# 12

print(permutations_count(4, 4))
# 24

scipy.special.perm ()

يوفر SciPy دالة scipy.special.perm () تُرجع العدد الإجمالي للتباديل. مطلوب تثبيت SciPy منفصل. متاح من الإصدار 0.14.0.

from scipy.special import perm

print(perm(4, 2))
# 12.0

print(perm(4, 2, exact=True))
# 12

print(perm(4, 4, exact=True))
# 24

exact=False
يتم تعيين الوسيطة الثالثة على النحو الوارد أعلاه افتراضيًا وتُرجع رقم الفاصلة العائمة. لاحظ أنه إذا كنت تريد الحصول عليه كعدد صحيح ، فأنت بحاجة إلى تعيينه على النحو التالي.
exact=True

لاحظ أن “استيراد scipy” فقط لن يتم تحميل الوحدة النمطية scipy.special.

نفِّذ perm () كـ “from scipy.special import perm” كما في المثال أعلاه ، أو نفِّذ scipy.special.perm () كـ “import scipy.special”.

توليد وتعداد التباديل من قائمة:itertools.permutations()

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

استخدم وظيفة التباديل () للوحدة النمطية itertools.

يؤدي تمرير نوع متكرر (قائمة أو نوع مجموعة) باعتباره الوسيطة الأولى وعدد القطع المراد تحديدها كالوسيطة الثانية إلى إرجاع مكرر لهذا التبديل.

import itertools

l = ['a', 'b', 'c', 'd']

p = itertools.permutations(l, 2)

print(type(p))
# <class 'itertools.permutations'>

لتعدادهم جميعًا ، يمكنك استخدام حلقة for.

for v in itertools.permutations(l, 2):
    print(v)
# ('a', 'b')
# ('a', 'c')
# ('a', 'd')
# ('b', 'a')
# ('b', 'c')
# ('b', 'd')
# ('c', 'a')
# ('c', 'b')
# ('c', 'd')
# ('d', 'a')
# ('d', 'b')
# ('d', 'c')

نظرًا لأنه مكرر محدود ، يمكن أيضًا تحويله إلى نوع قائمة مع list ().

عندما يتم الحصول على عدد العناصر في القائمة باستخدام len () ، يمكن التأكد من أنه يطابق العدد الإجمالي للتباديل المحسوب من العامل.

p_list = list(itertools.permutations(l, 2))

print(p_list)
# [('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'a'), ('b', 'c'), ('b', 'd'), ('c', 'a'), ('c', 'b'), ('c', 'd'), ('d', 'a'), ('d', 'b'), ('d', 'c')]

print(len(p_list))
# 12

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

for v in itertools.permutations(l):
    print(v)
# ('a', 'b', 'c', 'd')
# ('a', 'b', 'd', 'c')
# ('a', 'c', 'b', 'd')
# ('a', 'c', 'd', 'b')
# ('a', 'd', 'b', 'c')
# ('a', 'd', 'c', 'b')
# ('b', 'a', 'c', 'd')
# ('b', 'a', 'd', 'c')
# ('b', 'c', 'a', 'd')
# ('b', 'c', 'd', 'a')
# ('b', 'd', 'a', 'c')
# ('b', 'd', 'c', 'a')
# ('c', 'a', 'b', 'd')
# ('c', 'a', 'd', 'b')
# ('c', 'b', 'a', 'd')
# ('c', 'b', 'd', 'a')
# ('c', 'd', 'a', 'b')
# ('c', 'd', 'b', 'a')
# ('d', 'a', 'b', 'c')
# ('d', 'a', 'c', 'b')
# ('d', 'b', 'a', 'c')
# ('d', 'b', 'c', 'a')
# ('d', 'c', 'a', 'b')
# ('d', 'c', 'b', 'a')

print(len(list(itertools.permutations(l))))
# 24

في itertools.permutations () ، يتم التعامل مع العناصر بناءً على الموضع وليس القيمة. لا تؤخذ القيم المكررة في الاعتبار.

l = ['a', 'a']

for v in itertools.permutations(l, 2):
    print(v)
# ('a', 'a')
# ('a', 'a')

الأمر نفسه ينطبق على الوظائف التالية الموضحة أدناه.

  • itertools.combinations()
  • itertools.combinations_with_replacement()

احسب العدد الإجمالي للتركيبات

math.factorial()

عدد التركيبات هو عدد قطع r للاختيار من بينها n قطع مختلفة. الترتيب لا يعتبر في التباديل.

يتم الحصول على العدد الإجمالي للتركيبات c بالمعادلة التالية.

c = n! / (r! * (n - r)!)

يمكن حسابها على النحو التالي باستخدام دالة math.factorial () التي ترجع العامل. يتم استخدام عامل التشغيل ⌘ ، الذي ينفذ قسمة عدد صحيح ، لإرجاع نوع عدد صحيح.

def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

print(combinations_count(4, 2))
# 6

scipy.special.comb()

يوفر SciPy دالة scipy.special.comb () تُرجع العدد الإجمالي للتباديل. مطلوب تثبيت SciPy منفصل. متاح من الإصدار 0.14.0. لاحظ أن scipy.misc.comb () لا تنفذ تكرار الوسيطة الموضح أدناه.

from scipy.special import comb

print(comb(4, 2))
# 6.0

print(comb(4, 2, exact=True))
# 6

print(comb(4, 0, exact=True))
# 1

exact=False
كما هو الحال مع scipy.special.perm () ، يتم تعيين الوسيطة الثالثة على النحو الوارد أعلاه افتراضيًا وتُرجع رقم الفاصلة العائمة. لاحظ أنه إذا كنت تريد الحصول عليه كعدد صحيح ، فأنت بحاجة إلى تعيينه على النحو التالي.
exact=True
يمكن أيضًا الحصول على العدد الإجمالي للنُسخ المكررة باستخدام الوسيطة الرابعة ، التكرار. هذا موضح أدناه.

مرة أخرى ، لاحظ أن “استيراد scipy” فقط لن يتم تحميل الوحدة النمطية scipy.special.

كما في المثال أعلاه ، نفّذ comb () كـ “from scipy.special import comb” أو نفّذ scipy.special.comb () كـ “import scipy.special”. الأمر نفسه ينطبق على “scipy.misc”.

كيف لا تستخدم math.factorial ()

هناك طريقة أخرى تستخدم المكتبة القياسية فقط وهي أسرع من الطريقة التي تستخدم math.factorial () وهي الطريقة التالية.

from operator import mul
from functools import reduce

def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom

print(combinations_count(4, 2))
# 6

print(combinations_count(4, 0))
# 1

إنشاء وتعداد مجموعات من القوائم:itertools.combinations()

من الممكن إنشاء وتعداد جميع التركيبات من القوائم (المصفوفات) ، إلخ ، بالإضافة إلى الأرقام الإجمالية.

استخدم وظيفة المجموعات () للوحدة النمطية itertools.

يؤدي تمرير عنصر متكرر (قائمة أو نوع مجموعة) باعتباره الوسيطة الأولى وعدد القطع المراد تحديدها كالوسيطة الثانية إلى إرجاع مكرر هذه المجموعة.

l = ['a', 'b', 'c', 'd']

c = itertools.combinations(l, 2)

print(type(c))
# <class 'itertools.combinations'>

for v in itertools.combinations(l, 2):
    print(v)
# ('a', 'b')
# ('a', 'c')
# ('a', 'd')
# ('b', 'c')
# ('b', 'd')
# ('c', 'd')

c_list = list(itertools.combinations(l, 2))

print(c_list)
# [('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')]

print(len(c_list))
# 6

احسب العدد الإجمالي للمجموعات المكررة

عدد التركيبات المكررة هو عدد الحالات التي يتم فيها اختيار r من بين n مختلفة ، مما يسمح بالنسخ المكررة.

العدد الإجمالي للتركيبات المكررة يساوي عدد التركيبات للاختيار (r) من (n + r – 1) مختلفة.

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

def combinations_with_replacement_count(n, r):
    return combinations_count(n + r - 1, r)

print(combinations_with_replacement_count(4, 2))
# 10

في “scipy.special.comb ()” الموصوفة أعلاه ، يمكن الحصول على العدد الإجمالي للتركيبات المكررة عن طريق تعيين الوسيطة الرابعة “repetition = True.
لاحظ أن الوسيطة “repetition” لم يتم تنفيذها في “scipy.misc.comb ()” في الإصدارات السابقة لـ “SciPy0.14.0”.

from scipy.special import comb

print(comb(4, 2, exact=True, repetition=True))
# 10

إنشاء وتعداد مجموعات مكررة من قائمة:itertools.combinations_with_replacement()

من الممكن إنشاء وتعداد جميع المجموعات المكررة من القوائم (المصفوفات) ، إلخ ، بالإضافة إلى الأرقام الإجمالية.

استخدم الدالة combinations_with_replacement () في الوحدة النمطية itertools.

يؤدي تمرير عنصر متكرر (قائمة أو نوع مجموعة) باعتباره الوسيطة الأولى وعدد القطع المراد تحديدها كالوسيطة الثانية إلى إرجاع مكرر لتلك المجموعة المتداخلة.

h = itertools.combinations_with_replacement(l, 2)

print(type(h))
# <class 'itertools.combinations_with_replacement'>

for v in itertools.combinations_with_replacement(l, 2):
    print(v)
# ('a', 'a')
# ('a', 'b')
# ('a', 'c')
# ('a', 'd')
# ('b', 'b')
# ('b', 'c')
# ('b', 'd')
# ('c', 'c')
# ('c', 'd')
# ('d', 'd')

h_list = list(itertools.combinations_with_replacement(l, 2))

print(h_list)
# [('a', 'a'), ('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'b'), ('b', 'c'), ('b', 'd'), ('c', 'c'), ('c', 'd'), ('d', 'd')]

print(len(h_list))
# 10

إنشاء الجناس الناقصة من السلاسل

يجعل Itertools.permutations () من السهل إنشاء تباديل السلسلة (الجناس الناقصة).

s = 'arc'

for v in itertools.permutations(s):
    print(v)
# ('a', 'r', 'c')
# ('a', 'c', 'r')
# ('r', 'a', 'c')
# ('r', 'c', 'a')
# ('c', 'a', 'r')
# ('c', 'r', 'a')

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

anagram_list = [''.join(v) for v in itertools.permutations(s)]

print(anagram_list)
# ['arc', 'acr', 'rac', 'rca', 'car', 'cra']

يتم استخدام طريقة Join () ، التي تجمع عناصر قائمة أو مجموعة في سلسلة ، وتدوين list comprehension.