Llogaritni dhe gjeneroni faktoriale, permutacione dhe kombinime në Python

biznes

Matematika standarde e modulit për funksionet matematikore në Python mund të përdoret për të llogaritur faktorët. SciPy gjithashtu ka funksione për të llogaritur numrin total të permutacioneve/kombinimeve.

Moduli itertools mund të përdoret gjithashtu për të gjeneruar permutacione dhe kombinime nga listat (vargjet), etj., dhe për t’i numëruar ato.

Më poshtë shpjegohet këtu, së bashku me kodin e mostrës.

  • faktorial:math.factorial()
  • Llogaritni numrin total të permutacioneve
    • math.factorial()
    • scipy.special.perm()
  • Gjeneroni dhe numëroni permutacione nga një listë:itertools.permutations()
  • Llogaritni numrin total të kombinimeve
    • math.factorial()
    • scipy.special.comb()
    • Si të mos përdorni math.factorial()
  • Gjeneroni dhe numëroni kombinime nga listat:itertools.combinations()
  • Llogaritni numrin total të kombinimeve të kopjuara
  • Gjeneroni dhe numëroni kombinime të kopjuara nga një listë:itertools.combinations_with_replacement()

Si shembull i përdorimit të permutacioneve, shpjegohet edhe më poshtë.

  • Krijoni anagrame nga vargjet

Nëse dëshironi të gjeneroni një kombinim të elementeve të listimeve të shumta në vend të një listimi të vetëm, përdorni itertools.product() në modulin itertools.

faktorial:math.factorial()

Moduli i matematikës ofron një funksion faktorial() që kthen faktorialin.

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

Vlerat jo të plota, negative do të rezultojnë në një ValueError.

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

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

Llogaritni numrin total të permutacioneve

math.factorial()

Permutacionet janë numri i rasteve ku r zgjidhen nga n të ndryshme dhe vendosen në një rresht.

Numri i përgjithshëm i permutacioneve, p, merret nga ekuacioni i mëposhtëm duke përdorur faktorialët.

p = n! / (n - r)!

Mund të llogaritet si më poshtë duke përdorur funksionin math.factorial(), i cili kthen faktorialin. Operatori ⌘, i cili kryen ndarjen e numrave të plotë, përdoret për të kthyer një lloj të numrit të plotë.

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 ofron një funksion scipy.special.perm() që kthen numrin total të permutacioneve. Kërkohet një instalim i veçantë SciPy. Në dispozicion nga versioni 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
Argumenti i tretë vendoset si më sipër si parazgjedhje dhe kthen një numër me pikë lundruese. Vini re se nëse dëshironi ta merrni si numër të plotë, duhet ta vendosni si më poshtë.
exact=True

Vini re se vetëm “import scipy” nuk do të ngarkojë modulin scipy.special.

Ekzekutoni perm() si “nga scipy.special import perm” si në shembullin e mësipërm, ose ekzekutoni scipy.special.perm() si “import scipy.special”.

Gjeneroni dhe numëroni permutacione nga një listë:itertools.permutations()

Jo vetëm numrat totalë, por edhe permutacionet mund të gjenerohen dhe numërohen nga listat (vargjet), etj.

Përdorni funksionin permutations() të modulit itertools.

Kalimi i një iterabil (liste ose lloj grupi) si argumenti i parë dhe numri i pjesëve që do të zgjidhen si argumenti i dytë kthen një përsëritës për atë ndryshim.

import itertools

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

p = itertools.permutations(l, 2)

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

Për t’i numëruar të gjitha, mund të përdorni një lak 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')

Meqenëse është një përsëritës i fundëm, ai gjithashtu mund të konvertohet në një lloj liste me list().

Kur numri i elementeve në listë merret me len(), mund të konfirmohet se përputhet me numrin total të permutacioneve të llogaritura nga faktoriali.

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

Nëse hiqet argumenti i dytë, rikthimi për zgjedhjen e të gjithë elementëve kthehet.

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

Në itertools.permutations(), elementët trajtohen në bazë të pozicionit, jo të vlerës. Vlerat e dyfishta nuk merren parasysh.

l = ['a', 'a']

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

E njëjta gjë vlen edhe për funksionet e mëposhtme, të përshkruara më poshtë.

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

Llogaritni numrin total të kombinimeve

math.factorial()

Numri i kombinimeve është numri i r pjesëve për të zgjedhur nga n pjesë të ndryshme. Rendi nuk konsiderohet si në permutacione.

Numri i përgjithshëm i kombinimeve c fitohet nga ekuacioni i mëposhtëm.

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

Mund të llogaritet si më poshtë duke përdorur funksionin math.factorial(), i cili kthen faktorialin. Operatori ⌘, i cili kryen ndarjen e numrave të plotë, përdoret për të kthyer një lloj të numrit të plotë.

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 ofron një funksion scipy.special.comb() që kthen numrin total të permutacioneve. Kërkohet një instalim i veçantë SciPy. Në dispozicion nga versioni 0.14.0. Vini re se scipy.misc.comb() nuk zbaton përsëritjen e argumentit të përshkruar më poshtë.

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
Ashtu si me scipy.special.perm(), argumenti i tretë vendoset si më sipër si parazgjedhje dhe kthen një numër me pikë lundruese. Vini re se nëse dëshironi ta merrni si numër të plotë, duhet ta vendosni si më poshtë.
exact=True
Numri i përgjithshëm i kombinimeve të dyfishta mund të merret edhe me argumentin e katërt, përsëritjen. Kjo përshkruhet më poshtë.

Përsëri, vini re se vetëm “import scipy” nuk do të ngarkojë modulin scipy.special.

Ashtu si në shembullin e mësipërm, ekzekutoni comb() si “nga scipy.special import comb” ose ekzekutoni scipy.special.comb() si “import scipy.special”. E njëjta gjë vlen edhe për “scipy.misc”.

Si të mos përdorni math.factorial()

Një metodë tjetër që përdor vetëm bibliotekën standarde dhe është më e shpejtë se metoda që përdor math.factorial() është metoda e mëposhtme.

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

Gjeneroni dhe numëroni kombinime nga listat:itertools.combinations()

Është e mundur të gjenerohen dhe numërohen të gjitha kombinimet nga listat (vargjet) etj. si dhe numrat total.

Përdorni funksionin combinations() të modulit itertools.

Kalimi i një iterabilit (lista ose lloji i grupit) si argumenti i parë dhe numri i pjesëve që do të zgjidhen si argumenti i dytë kthen përsëritësin për atë kombinim.

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

Llogaritni numrin total të kombinimeve të kopjuara

Numri i kombinimeve të kopjuara është numri i rasteve në të cilat r zgjidhen nga n të ndryshme, duke lejuar dublikatat.

Numri i përgjithshëm i kombinimeve të dyfishta është i barabartë me numrin e kombinimeve për të zgjedhur (r) nga (n + r – 1) të ndryshme.

Prandaj, ne mund të përdorim funksionin e përcaktuar më sipër për të llogaritur numrin total të kombinimeve.

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

print(combinations_with_replacement_count(4, 2))
# 10

Në “scipy.special.comb()” të përshkruar më sipër, numri i përgjithshëm i kombinimeve të kopjuara mund të merret duke vendosur argumentin e katërt “përsëritje=E vërtetë.
Vini re se argumenti “përsëritje” nuk zbatohet në “scipy.misc.comb()” në versionet para “SciPy0.14.0”.

from scipy.special import comb

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

Gjeneroni dhe numëroni kombinime të kopjuara nga një listë:itertools.combinations_with_replacement()

Është e mundur të gjenerohen dhe numërohen të gjitha kombinimet e kopjuara nga listat (vargjet), etj. si dhe numrat total.

Përdorni funksionin combinations_with_replacement() në modulin itertools.

Kalimi i një iterable (liste ose lloj grupi) si argumenti i parë dhe numri i pjesëve që do të zgjidhen si argumenti i dytë kthen një përsëritës për atë kombinim të mbivendosur.

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

Krijoni anagrame nga vargjet

Itertools.permutations() e bën të lehtë krijimin e permutacioneve të vargjeve (anagrame).

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')

Për të kombinuar një tufë me një karakter në një kohë në një varg dhe për ta bërë atë në një listë, bëni sa më poshtë

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

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

Përdoret metoda join(), e cila bashkon elementet e një liste ose tuple në një varg dhe shënimi i kuptimit të listës.

Copied title and URL