Reiknaðu og búðu til þátta, umbreytingar og samsetningar í Python

Viðskipti

Hægt er að nota staðlaða stærðfræðieininguna fyrir stærðfræðilegar aðgerðir í Python til að reikna út þætti. SciPy hefur einnig aðgerðir til að reikna út heildarfjölda umbreytinga/samsetninga.

Itertools eininguna er einnig hægt að nota til að búa til umbreytingar og samsetningar úr listum (fylki) o.s.frv., og telja þær upp.

Eftirfarandi er útskýrt hér ásamt sýnishornskóða.

  • þáttagerð:math.factorial()
  • Reiknaðu heildarfjölda umbreytinga
    • math.factorial()
    • scipy.special.perm()
  • Búðu til og taldu upp umbreytingar úr lista:itertools.permutations()
  • Reiknaðu heildarfjölda samsetninga
    • math.factorial()
    • scipy.special.comb()
    • Hvernig á ekki að nota math.fatorial()
  • Búðu til og taldu upp samsetningar úr listum:itertools.combinations()
  • Reiknaðu heildarfjölda tvítekinna samsetninga
  • Búðu til og taldu upp tvíteknar samsetningar af lista:itertools.combinations_with_replacement()

Sem dæmi um notkun umbreytinga er eftirfarandi einnig útskýrt.

  • Búðu til anagram úr strengjum

Ef þú vilt búa til samsetningu þátta í mörgum skráningum í stað einnar skráningar, notaðu itertools.product() í itertools einingunni.

þáttagerð:math.factorial()

Stærðfræðieiningin veitir fall þátta() sem skilar hlutfallinu.

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

Neikvæð gildi sem ekki eru heiltölu munu leiða til ValueError.

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

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

Reiknaðu heildarfjölda umbreytinga

math.factorial()

Breytingar eru fjöldi tilvika þar sem r er valið úr n mismunandi og sett í röð.

Heildarfjöldi breytinga, p, er fenginn með eftirfarandi jöfnu með stuðliðum.

p = n! / (n - r)!

Það er hægt að reikna það sem hér segir með því að nota fallið math.fatorial(), sem skilar þáttagildinu. Operatorinn ⌘, sem framkvæmir heiltöluskiptingu, er notaður til að skila heiltölugerð.

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 býður upp á fall scipy.special.perm() sem skilar heildarfjölda umbreytinga. Sérstök SciPy uppsetning er nauðsynleg. Í boði frá útgáfu 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
Þriðja röksemdin er sjálfgefið stillt eins og hér að ofan og skilar flottölu. Athugaðu að ef þú vilt fá það sem heiltölu þarftu að stilla það sem hér segir.
exact=True

Athugaðu að aðeins „import scipy“ mun ekki hlaða scipy.special einingunni.

Keyrðu perm() sem „from scipy.special import perm“ eins og í dæminu hér að ofan, eða keyrðu scipy.special.perm() sem „import scipy.special“.

Búðu til og taldu upp umbreytingar úr lista:itertools.permutations()

Ekki aðeins heildartölur, heldur einnig umbreytingar er hægt að búa til og telja upp úr listum (fylki) o.s.frv.

Notaðu permutations() fallið í itertools einingunni.

Með því að senda ítrekanlegan (lista eða tegund mengis) sem fyrstu viðmiðun og fjölda hluta sem á að velja sem seinni viðfang skilar endurtekningu fyrir þá umbreytingu.

import itertools

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

p = itertools.permutations(l, 2)

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

Til að telja þær allar upp er hægt að nota for lykkju.

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

Þar sem það er endanleg endurtekning, er einnig hægt að breyta því í listategund með list().

Þegar fjöldi þátta í listanum er fenginn með len() er hægt að staðfesta að það passi við heildarfjölda umbreytinga sem reiknuð eru út frá þáttaskilum.

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

Ef seinni röksemdinni er sleppt er skiptingunni fyrir val á öllum þáttum skilað.

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() eru þættir meðhöndlaðir út frá stöðu, ekki gildi. Ekki er tekið tillit til tvítekinna gilda.

l = ['a', 'a']

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

Sama á við um eftirfarandi aðgerðir, sem lýst er hér að neðan.

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

Reiknaðu heildarfjölda samsetninga

math.factorial()

Fjöldi samsetninga er fjöldi r stykki til að velja úr n mismunandi stykki. Pöntunin er ekki talin vera í umbreytingum.

Heildarfjöldi samsetninga c fæst með eftirfarandi jöfnu.

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

Það er hægt að reikna það sem hér segir með því að nota fallið math.fatorial(), sem skilar þáttagildinu. Operatorinn ⌘, sem framkvæmir heiltöluskiptingu, er notaður til að skila heiltölugerð.

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 býður upp á fall scipy.special.comb() sem skilar heildarfjölda umbreytinga. Sérstök SciPy uppsetning er nauðsynleg. Í boði frá útgáfu 0.14.0. Athugaðu að scipy.misc.comb() útfærir ekki endurtekningu rifrilda sem lýst er hér að neðan.

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
Eins og með scipy.special.perm(), þá er þriðji rökstuðningurinn sjálfgefið stilltur eins og hér að ofan og skilar fljótandi tölu. Athugaðu að ef þú vilt fá það sem heiltölu þarftu að stilla það sem hér segir.
exact=True
Heildarfjölda tvítekinna samsetninga er einnig hægt að fá með fjórðu röksemdinni, endurtekningu. Þessu er lýst hér að neðan.

Aftur, athugaðu að aðeins „innflutningur scipy“ mun ekki hlaða scipy.special einingunni.

Eins og í dæminu hér að ofan, keyrðu comb() sem „from scipy.special import comb“ eða keyrðu scipy.special.comb() sem „import scipy.special“. Sama á við um „scipy.misc“.

Hvernig á ekki að nota math.fatorial()

Önnur aðferð sem notar aðeins staðlaða bókasafnið og er hraðari en aðferðin sem notar math.fatorial() er eftirfarandi aðferð.

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

Búðu til og taldu upp samsetningar úr listum:itertools.combinations()

Það er hægt að búa til og telja upp allar samsetningar úr listum (fylki) o.s.frv. sem og heildartölur.

Notaðu samsetningar() fallið í itertools einingunni.

Með því að senda ítrekanlegan (lista eða mengunartegund) sem fyrstu frumbreytu og fjölda hluta sem á að velja sem seinni frumbreytu skilar endurteknum fyrir þá samsetningu.

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

Reiknaðu heildarfjölda tvítekinna samsetninga

Fjöldi tvítekinna samsetninga er fjöldi tilvika þar sem r eru valin úr n mismunandi, sem gerir ráð fyrir tvíteknum.

Heildarfjöldi tvítekinna samsetninga er jafn fjölda samsetninga til að velja (r) úr (n + r – 1) mismunandi.

Þess vegna getum við notað fallið sem skilgreint er hér að ofan til að reikna út heildarfjölda samsetninga.

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()“ sem lýst er hér að ofan er hægt að fá heildarfjölda tvítekinna samsetninga með því að setja fjórðu röksemdina „repetition=True.
Athugaðu að röksemdin „endurtekning“ er ekki útfærð í „scipy.misc.comb()“ í útgáfum á undan „SciPy0.14.0“.

from scipy.special import comb

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

Búðu til og taldu upp tvíteknar samsetningar af lista:itertools.combinations_with_replacement()

Það er hægt að búa til og telja upp allar tvíteknar samsetningar úr listum (fylki) o.s.frv. sem og heildartölur.

Notaðu aðgerðina combines_with_replacement() í itertools einingunni.

Með því að senda ítrekanlegan (lista eða mengunartegund) sem fyrstu viðmiðunina og fjölda hluta sem á að velja sem seinni frumbreytuna skilar endurtekningu fyrir þá samsetningu sem skarast.

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

Búðu til anagram úr strengjum

Itertools.permutations() gerir það auðvelt að búa til strengjabreytingar (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')

Til að sameina túllu af einum staf í einu í streng og gera það í lista, gerðu eftirfarandi

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

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

join() aðferðin, sem sameinar þætti lista eða tuple í streng, og listaskilningur eru notuð.