Kokotoa na utengeneze nyenzo, vibali na mchanganyiko katika Python

Biashara

Hesabu ya kawaida ya moduli ya kazi za hisabati katika Python inaweza kutumika kukokotoa vipengele. SciPy pia ina utendakazi wa kukokotoa jumla ya idadi ya vibali/michanganyiko.

Moduli ya itertools pia inaweza kutumika kutengeneza vibali na michanganyiko kutoka kwa orodha (safu), n.k., na kuziorodhesha.

Ifuatayo imeelezewa hapa, pamoja na nambari ya mfano.

  • ya kiwandani:math.factorial()
  • Hesabu jumla ya idadi ya vibali
    • math.factorial()
    • scipy.special.perm()
  • Tengeneza na uhesabu vibali kutoka kwenye orodha:itertools.permutations()
  • Hesabu jumla ya idadi ya michanganyiko
    • math.factorial()
    • scipy.special.comb()
    • Jinsi ya kutotumia math.factorial()
  • Tengeneza na uhesabu michanganyiko kutoka kwa orodha:itertools.combinations()
  • Hesabu jumla ya idadi ya michanganyiko inayorudiwa
  • Tengeneza na uorodheshe michanganyiko nakala kutoka kwenye orodha:itertools.combinations_with_replacement()

Kama mfano wa kutumia vibali, yafuatayo pia yanaelezewa.

  • Unda anagrams kutoka kwa kamba

Iwapo ungependa kutoa mchanganyiko wa vipengele vya uorodheshaji nyingi badala ya tangazo moja, tumia itertools.product() katika sehemu ya itertools.

ya kiwandani:math.factorial()

Moduli ya hesabu hutoa kipengele cha kukokotoa () ambacho hurejesha kipengele.

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

Nambari zisizo kamili, zisizo kamili zitasababisha ValueError.

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

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

Hesabu jumla ya idadi ya vibali

math.factorial()

Ruhusa ni idadi ya matukio ambapo r huchaguliwa kutoka n tofauti na kuwekwa kwa safu.

Jumla ya idadi ya vibali, p, hupatikana kwa equation ifuatayo kwa kutumia factorials.

p = n! / (n - r)!

Inaweza kuhesabiwa kama ifuatavyo kwa kutumia chaguo za kukokotoa math.factorial(), ambayo hurejesha kipengele. Opereta ⌘, ambayo hufanya mgawanyiko kamili, hutumika kurudisha aina kamili.

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 hutoa chaguo la kukokotoa scipy.special.perm() ambalo hurejesha jumla ya idadi ya vibali. Usakinishaji tofauti wa SciPy unahitajika. Inapatikana kutoka toleo la 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
Hoja ya tatu imewekwa kama ilivyo hapo juu kwa chaguo-msingi na inarudisha nambari ya sehemu inayoelea. Kumbuka kwamba ikiwa unataka kuipata kama nambari kamili, unahitaji kuiweka kama ifuatavyo.
exact=True

Kumbuka kuwa “kuagiza scipy” pekee haitapakia moduli ya scipy.special.

Tekeleza perm() kama “kutoka scipy.idhini maalum ya kuingiza” kama ilivyo kwenye mfano ulio hapo juu, au utekeleze scipy.special.perm() kama “kuagiza scipy.special”.

Tengeneza na uhesabu vibali kutoka kwenye orodha:itertools.permutations()

Sio tu nambari za jumla, lakini pia vibali vinaweza kuzalishwa na kuorodheshwa kutoka kwa orodha (safu), nk.

Tumia permutations() kitendakazi cha moduli ya itertools.

Kupitisha iterable (orodha au aina iliyowekwa) kama hoja ya kwanza na idadi ya vipande vya kuchaguliwa kama hoja ya pili hurejesha kiboreshaji kwa idhini hiyo.

import itertools

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

p = itertools.permutations(l, 2)

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

Ili kuhesabu zote, unaweza kutumia kitanzi.

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

Kwa kuwa ni kiboreshaji kikomo, kinaweza pia kubadilishwa kuwa aina ya orodha iliyo na list().

Wakati idadi ya vipengee kwenye orodha inapopatikana kwa len(), inaweza kuthibitishwa kuwa inalingana na jumla ya idadi ya vibali vilivyohesabiwa kutoka kwa factorial.

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

Ikiwa hoja ya pili itaachwa, ruhusa ya kuchagua vipengele vyote inarudishwa.

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

Katika itertools.permutations(), vipengele vinatibiwa kulingana na nafasi, sio thamani. Maadili yanayorudiwa hayazingatiwi.

l = ['a', 'a']

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

Vile vile hutumika kwa kazi zifuatazo, zilizoelezwa hapa chini.

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

Hesabu jumla ya idadi ya michanganyiko

math.factorial()

Idadi ya michanganyiko ni idadi ya vipande r kuchagua kutoka n vipande tofauti. Agizo halizingatiwi kama katika vibali.

Jumla ya idadi ya mchanganyiko c hupatikana kwa equation ifuatayo.

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

Inaweza kuhesabiwa kama ifuatavyo kwa kutumia chaguo za kukokotoa math.factorial(), ambayo hurejesha kipengele. Opereta ⌘, ambayo hufanya mgawanyiko kamili, hutumika kurudisha aina kamili.

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 hutoa chaguo la kukokotoa scipy.special.comb() ambalo hurejesha jumla ya idadi ya vibali. Usakinishaji tofauti wa SciPy unahitajika. Inapatikana kutoka toleo la 0.14.0. Kumbuka kuwa scipy.misc.comb() haitekelezi marudio ya hoja iliyofafanuliwa hapa chini.

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
Kama ilivyo kwa scipy.special.perm(), hoja ya tatu imewekwa kama ilivyo hapo juu kwa chaguo-msingi na hurejesha nambari ya sehemu inayoelea. Kumbuka kwamba ikiwa unataka kuipata kama nambari kamili, unahitaji kuiweka kama ifuatavyo.
exact=True
Jumla ya idadi ya michanganyiko ya nakala inaweza pia kupatikana kwa hoja ya nne, marudio. Hii imeelezwa hapa chini.

Tena, kumbuka kuwa “kuagiza scipy” pekee haitapakia moduli ya scipy.special.

Kama ilivyo kwenye mfano hapo juu, tekeleza comb() kama “kutoka kwa scipy.special import comb” au tekeleza scipy.special.comb() kama “kuagiza scipy.special”. Vile vile hutumika kwa “scipy.misc”.

Jinsi ya kutotumia math.factorial()

Njia nyingine inayotumia maktaba ya kawaida pekee na ni ya haraka kuliko mbinu ya kutumia math.factorial() ni njia ifuatayo.

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

Tengeneza na uhesabu michanganyiko kutoka kwa orodha:itertools.combinations()

Inawezekana kuzalisha na kuhesabu michanganyiko yote kutoka kwa orodha (safu), nk. pamoja na nambari za jumla.

Tumia mchanganyiko() utendaji wa moduli ya itertools.

Kupitisha iterable (orodha au aina iliyowekwa) kama hoja ya kwanza na idadi ya vipande vya kuchaguliwa kama hoja ya pili hurejesha kiboreshaji cha mseto huo.

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

Hesabu jumla ya idadi ya michanganyiko inayorudiwa

Idadi ya michanganyiko ya nakala ni idadi ya kesi ambazo r huchaguliwa kutoka kwa n tofauti, kuruhusu nakala.

Jumla ya idadi ya michanganyiko iliyorudiwa ni sawa na idadi ya michanganyiko ya kuchagua (r) kati ya (n + r – 1) tofauti.

Kwa hiyo, tunaweza kutumia kazi iliyoelezwa hapo juu ili kuhesabu jumla ya idadi ya mchanganyiko.

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

print(combinations_with_replacement_count(4, 2))
# 10

Katika “scipy.special.comb()” iliyoelezwa hapo juu, jumla ya idadi ya michanganyiko inayorudiwa inaweza kupatikana kwa kuweka hoja ya nne “repetition=True.
Kumbuka kuwa hoja “marudio” haijatekelezwa katika “scipy.misc.comb()” katika matoleo kabla ya “SciPy0.14.0”.

from scipy.special import comb

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

Tengeneza na uorodheshe michanganyiko nakala kutoka kwenye orodha:itertools.combinations_with_replacement()

Inawezekana kuzalisha na kuhesabu michanganyiko yote iliyorudiwa kutoka kwa orodha (safu), nk. pamoja na nambari jumla.

Tumia mchanganyiko_with_replacement() chaguo za kukokotoa katika moduli ya itertools.

Kupitisha iterable (orodha au aina iliyowekwa) kama hoja ya kwanza na idadi ya vipande vya kuchaguliwa kama hoja ya pili hurejesha kirudia kwa mseto huo unaopishana.

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

Unda anagrams kutoka kwa kamba

Itertools.permutations() hurahisisha kuunda vibali vya kamba (anagrams).

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

Ili kuchanganya nakala ya herufi moja kwa wakati kwenye mfuatano na kuifanya kuwa orodha, fanya yafuatayo

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

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

Mbinu ya join(), ambayo inaambatanisha vipengele vya orodha au tuple kwenye mfuatano, na nukuu ya ufahamu wa orodha hutumiwa.

Copied title and URL