Pythonin matemaattisten funktioiden standardimoduulia math voidaan käyttää faktoriaalien laskemiseen. SciPyssä on myös funktioita, joilla voidaan laskea permutaatioiden\kombinaatioiden kokonaismäärä.
itertools-moduulia voidaan käyttää myös permutaatioiden ja yhdistelmien luomiseen listoista (taulukoista) jne. ja niiden luettelemiseen.
Seuraavat asiat selitetään tässä yhdessä esimerkkikoodin kanssa.
- Faktoriaali:
math.factorial() - Laske permutaatioiden kokonaismäärä.
math.factorial()scipy.special.perm()
- Luo ja luettele permutaatioita listasta.:
itertools.permutations() - Laske yhdistelmien kokonaismäärä
math.factorial()scipy.special.comb()- Miten math.factorial() -funktiota ei saa käyttää
- Luo ja luettele yhdistelmiä luetteloista:
itertools.combinations() - Laske päällekkäisten yhdistelmien kokonaismäärä.
- Luo ja luettele kaksoiskappaleyhdistelmiä luettelosta.:
itertools.combinations_with_replacement()
Esimerkkinä permutaatioiden käytöstä selitetään myös seuraavaa.
- Luo anagrammeja merkkijonoista
Jos haluat luoda yhdistelmän useiden listojen elementeistä yhden listan sijasta, käytä itertools-moduulin itertools.product() -ohjelmaa.
- Faktoriaali: math.factorial()
- Laske permutaatioiden kokonaismäärä.
- Luo ja luettele permutaatioita listasta.: itertools.permutations()
- Laske yhdistelmien kokonaismäärä
- Luo ja luettele yhdistelmiä luetteloista: itertools.combinations()
- Laske päällekkäisten yhdistelmien kokonaismäärä.
- Luo ja luettele kaksoiskappaleyhdistelmiä luettelosta.: itertools.combinations_with_replacement()
- Luo anagrammeja merkkijonoista
Faktoriaali: math.factorial()
Matematiikkamoduuli tarjoaa funktion factorial(), joka palauttaa faktoriaalin.
import math
print(math.factorial(5))
# 120
print(math.factorial(0))
# 1
Muut kuin kokonaislukuiset, negatiiviset arvot johtavat ValueError-virheeseen.
# print(math.factorial(1.5))
# ValueError: factorial() only accepts integral values
# print(math.factorial(-1))
# ValueError: factorial() not defined for negative values
Laske permutaatioiden kokonaismäärä.
math.factorial()
Permutaatiot ovat niiden tapausten lukumäärä, joissa r valitaan n:stä eri ruudusta ja sijoitetaan riviin.
Permutaatioiden kokonaismäärä p saadaan seuraavalla yhtälöllä, jossa käytetään faktoriaaleja.
p = n! / (n - r)!
Se voidaan laskea seuraavasti käyttämällä funktiota math.factorial(), joka palauttaa faktoriaalin. Kokonaislukujen jakamisen suorittavaa ⌘-operaattoria käytetään kokonaislukutyypin palauttamiseen.
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 tarjoaa funktion scipy.special.perm(), joka palauttaa permutaatioiden kokonaismäärän. Tarvitaan erillinen SciPy-asennus. Saatavilla versiosta 0.14.0 alkaen.
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
Kolmas argumentti asetetaan oletusarvoisesti kuten edellä, ja se palauttaa liukuluvun. Huomaa, että jos haluat saada sen kokonaislukuna, sinun on asetettava se seuraavasti.exact=True
Huomaa, että pelkkä ”import scipy” ei lataa scipy.special-moduulia.
Suorita perm() muodossa ”from scipy.special import perm” kuten yllä olevassa esimerkissä, tai suorita scipy.special.perm() muodossa ”import scipy.special”.
Luo ja luettele permutaatioita listasta.: itertools.permutations()
Kokonaislukujen lisäksi myös permutaatioita voidaan luoda ja luetella luetteloista (taulukoista) jne.
Käytä itertools-moduulin permutations()-funktiota.
Kun annat ensimmäisenä argumenttina iteraattorin (listan tai joukon tyyppi) ja toisena argumenttina valittujen kappaleiden määrän, saat takaisin kyseisen permutaation iteraattorin.
import itertools
l = ['a', 'b', 'c', 'd']
p = itertools.permutations(l, 2)
print(type(p))
# <class 'itertools.permutations'>
Voit luetella ne kaikki käyttämällä for-silmukkaa.
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')
Koska se on äärellinen iteraattori, se voidaan myös muuntaa listatyypiksi komennolla list().
Kun listan elementtien lukumäärä saadaan len()-operaatiolla, voidaan varmistaa, että se vastaa faktoriaalin avulla laskettua permutaatioiden kokonaismäärää.
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
Jos toinen argumentti jätetään pois, palautetaan kaikkien elementtien valintaan käytettävä permutaatio.
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()-ohjelmassa elementtejä käsitellään sijainnin, ei arvon perusteella. Kaksinkertaisia arvoja ei oteta huomioon.
l = ['a', 'a']
for v in itertools.permutations(l, 2):
print(v)
# ('a', 'a')
# ('a', 'a')
Sama pätee seuraavassa kuvattuihin toimintoihin.
itertools.combinations()itertools.combinations_with_replacement()
Laske yhdistelmien kokonaismäärä
math.factorial()
Yhdistelmien määrä on r kappaletta, joka voidaan valita n eri kappaleesta. Järjestystä ei oteta huomioon kuten permutaatioissa.
Yhdistelmien kokonaismäärä c saadaan seuraavan yhtälön avulla.
c = n! / (r! * (n - r)!)
Se voidaan laskea seuraavasti käyttämällä funktiota math.factorial(), joka palauttaa faktoriaalin. Kokonaislukujen jakamisen suorittavaa ⌘-operaattoria käytetään kokonaislukutyypin palauttamiseen.
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 tarjoaa funktion scipy.special.comb(), joka palauttaa permutaatioiden kokonaismäärän. Tarvitaan erillinen SciPy-asennus. Saatavilla versiosta 0.14.0 alkaen. Huomaa, että scipy.misc.comb() ei toteuta alla kuvattua argumenttien toistoa.
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
Kuten scipy.special.perm():n tapauksessa, kolmas argumentti asetetaan oletusarvoisesti kuten edellä, ja se palauttaa liukuluvun. Huomaa, että jos haluat saada sen kokonaislukuna, sinun on asetettava se seuraavasti.exact=True
Kaksoiskappaleyhdistelmien kokonaismäärä saadaan myös neljännen argumentin, toiston, avulla. Tätä kuvataan jäljempänä.
Huomaa jälleen, että pelkkä ”import scipy” ei lataa scipy.special-moduulia.
Kuten yllä olevassa esimerkissä, suorita comb() muodossa ”from scipy.special import comb” tai suorita scipy.special.comb() muodossa ”import scipy.special”. Sama pätee myös ”scipy.misc” -hakemistoon.
Miten math.factorial() -funktiota ei saa käyttää
Toinen menetelmä, joka käyttää vain standardikirjastoa ja on nopeampi kuin menetelmä, jossa käytetään math.factorial():a, on seuraava menetelmä.
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
Luo ja luettele yhdistelmiä luetteloista: itertools.combinations()
On mahdollista luoda ja luetella kaikki yhdistelmät luetteloista (taulukoista) jne. sekä kokonaisluvut.
Käytä itertools-moduulin combinations()-funktiota.
Kun annat ensimmäisenä argumenttina iteraattorin (listan tai set-tyypin) ja toisena argumenttina valittujen kappaleiden lukumäärän, saat takaisin kyseisen yhdistelmän iteraattorin.
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
Laske päällekkäisten yhdistelmien kokonaismäärä.
Kaksoiskombinaatioiden lukumäärä on niiden tapausten lukumäärä, joissa r valitaan n:stä eri yhdistelmästä, kun otetaan huomioon kaksoiskappaleet.
Kaksoiskombinaatioiden kokonaismäärä on yhtä suuri kuin (r) valittavien kombinaatioiden määrä (n + r – 1) eri kombinaatioiden joukosta.
Näin ollen voimme käyttää edellä määriteltyä funktiota yhdistelmien kokonaismäärän laskemiseen.
def combinations_with_replacement_count(n, r):
return combinations_count(n + r - 1, r)
print(combinations_with_replacement_count(4, 2))
# 10
Edellä kuvatussa komennossa ”scipy.special.comb()” kaksoiskombinaatioiden kokonaismäärä saadaan asettamalla neljäs argumentti ”repetition=True.
Huomaa, että argumenttia ”repetition” ei ole toteutettu ”scipy.misc.comb()”:ssa versioissa ennen ”SciPy0.14.0”.
from scipy.special import comb
print(comb(4, 2, exact=True, repetition=True))
# 10
Luo ja luettele kaksoiskappaleyhdistelmiä luettelosta.: itertools.combinations_with_replacement()
On mahdollista luoda ja luetella kaikki päällekkäiset yhdistelmät luetteloista (taulukoista) jne. sekä kokonaislukumäärät.
Käytä itertools-moduulin combinations_with_replacement()-funktiota.
Kun annat ensimmäisenä argumenttina iteraattorin (listan tai set-tyypin) ja toisena argumenttina valittavien kappaleiden lukumäärän, saat takaisin iteraattorin kyseiselle päällekkäiselle yhdistelmälle.
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
Luo anagrammeja merkkijonoista
Itertools.permutations() helpottaa merkkijonojen permutaatioiden (anagrammien) luomista.
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')
Jos haluat yhdistää yhden merkin sisältävän tuplan merkkijonoksi ja tehdä siitä listan, toimi seuraavasti
anagram_list = [''.join(v) for v in itertools.permutations(s)]
print(anagram_list)
# ['arc', 'acr', 'rac', 'rca', 'car', 'cra']
Käytetään join()-metodia, joka yhdistää listan tai tuplen elementit merkkijonoksi, ja listan ymmärtämisen merkintätapaa.
