統計：Pythonの組み合わせ
Pythonでコンビナトリアル（nCr）を計算する必要がありますが、math、numpy、またはstatライブラリでそれを行う関数が見つかりません。タイプの関数のようなもの：
comb = calculate_combinations(n, r)
実際の組み合わせではなく、可能な組み合わせの数が必要なので、itertools.combinationsは興味がありません。
最後に、組み合わせを計算する数値が大きくなりすぎて、階乗が巨大になるため、階乗の使用を避けたいと思います。
これは本当に簡単に答えられる質問のように思えますが、実際のすべての組み合わせを生成することについての質問にdrれています。
scipy.special.comb （scipyの古いバージョンのscipy.misc.comb）を参照してください。 exactがFalseの場合、gammaln関数を使用して、多くの時間を費やすことなく良好な精度を取得します。正確な場合、任意精度の整数を返しますが、計算に時間がかかる場合があります。
自分で書いてみませんか？それはワンライナーなどです：
from operator import mul # or mul=lambda x,y:x*y
from fractions import Fraction
def nCk(n,k):
return int( reduce(mul, (Fraction(n-i, i+1) for i in range(k)), 1) )
テスト-パスカルの三角形の印刷：
>>> for n in range(17):
... print ' '.join('%5d'%nCk(n,k) for k in range(n+1)).center(100)
...
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1
1 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1
1 14 91 364 1001 2002 3003 3432 3003 2002 1001 364 91 14 1
1 15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105 15 1
1 16 120 560 1820 4368 8008 11440 12870 11440 8008 4368 1820 560 120 16 1
>>>
PS。 int(round(reduce(mul, (float(n-i)/(i+1) for i in range(k)), 1)))をint(reduce(mul, (Fraction(n-i, i+1) for i in range(k)), 1))に置き換えるように編集されているため、大きなN/Kでエラーが発生しません。
グーグルコードをすばやく検索すると、（ @ Mark Byers's answer の式が使用されます）：
def choose(n, k):
"""
A fast way to calculate binomial coefficients by Andrew Dalke (contrib).
"""
if 0 <= k <= n:
ntok = 1
ktok = 1
for t in xrange(1, min(k, n - k) + 1):
ntok *= n
ktok *= t
n -= 1
return ntok // ktok
else:
return 0
正確な答えが必要な場合、choose()はscipy.misc.comb()よりも10倍高速です（すべての0 <=（n、k）<1e3ペアでテスト）。
def comb(N,k): # from scipy.comb(), but MODIFIED!
if (k > N) or (N < 0) or (k < 0):
return 0L
N,k = map(long,(N,k))
top = N
val = 1L
while (top > (N-k)):
val *= top
top -= 1
n = 1L
while (n < k+1L):
val /= n
n += 1
return val
正確な結果and速度が必要な場合は、 gmpy -gmpy.combを使用すると、正確に求めることができます。 andそれはかなり高速です（もちろん、gmpyの元の作者であるIamバイアス;-)。
正確な結果が必要な場合は、 sympy.binomial を使用します。最速の方法であると思われます。
x = 1000000
y = 234050
%timeit scipy.misc.comb(x, y, exact=True)
1 loops, best of 3: 1min 27s per loop
%timeit gmpy.comb(x, y)
1 loops, best of 3: 1.97 s per loop
%timeit int(sympy.binomial(x, y))
100000 loops, best of 3: 5.06 µs per loop
多くの場合、数学的な定義のリテラル変換は非常に適切です（Pythonは自動的に大きな数の算術を使用することに注意してください）
from math import factorial
def calculate_combinations(n, r):
return factorial(n) // factorial(r) // factorial(n-r)
私がテストした一部の入力（例：n = 1000 r = 500）では、これは別の（現在の最高票）の回答で提案された1つのライナーreduceよりも10倍以上高速でした。一方、@ J.Fが提供するスニペットは、パフォーマンスが優れています。セバスチャン。
別の選択肢があります。これはもともとC++で記述されていたため、有限精度整数（__int64など）のためにC++にバックポートできます。利点は、（1）整数演算のみを含むこと、および（2）乗算と除算の連続したペアを実行することにより整数値が肥大化することを回避することです。 Nas BanovのPascal三角形で結果をテストしましたが、正しい答えが得られます。
def choose(n,r):
"""Computes n! / (r! (n-r)!) exactly. Returns a python long int."""
assert n >= 0
assert 0 <= r <= n
c = 1L
denom = 1
for (num,denom) in Zip(xrange(n,n-r,-1), xrange(1,r+1,1)):
c = (c * num) // denom
return c
根拠：乗算と除算の数を最小限にするために、式を次のように書き直します。
n! n(n-1)...(n-r+1)
--------- = ----------------
r!(n-r)! r!
可能な限り乗算のオーバーフローを回避するために、左から右に、次の厳密な順序で評価します。
n / 1 * (n-1) / 2 * (n-2) / 3 * ... * (n-r+1) / r
この順序で演算される整数の算術演算が正確であることを示すことができます（つまり、丸め誤差はありません）。
動的計画法を使用すると、時間の複雑度はΘ（n * m）および空間の複雑度Θ（m）です。
def binomial(n, k):
""" (int, int) -> int
| c(n-1, k-1) + c(n-1, k), if 0 < k < n
c(n,k) = | 1 , if n = k
| 1 , if k = 0
Precondition: n > k
>>> binomial(9, 2)
36
"""
c = [0] * (n + 1)
c[0] = 1
for i in range(1, n + 1):
c[i] = 1
j = i - 1
while j > 0:
c[j] += c[j - 1]
j -= 1
return c[k]
プログラムにn（たとえばn <= N）の上限があり、nCrを繰り返し計算する必要がある場合（できれば>> N回）、 lru_cache を使用してパフォーマンスを大幅に向上させます。
from functools import lru_cache
@lru_cache(maxsize=None)
def nCr(n, r):
return 1 if r == 0 or r == n else nCr(n - 1, r - 1) + nCr(n - 1, r)
キャッシュの構築（暗黙的に行われます）には最大O(N^2)時間かかります。 nCrへの以降の呼び出しは、O(1)で返されます。
scipy.special.comb を使用するよりも実際に約5〜8倍高速であることが判明した2つの単純な関数を記述できます。実際、追加のパッケージをインポートする必要はなく、関数は非常に簡単に読み取り可能です。秘Theは、メモ化を使用して以前に計算された値を保存し、 nCr の定義を使用することです
# create a memoization dict
memo = {}
def factorial(n):
"""
Calculate the factorial of an input using memoization
:param n: int
:rtype value: int
"""
if n in [1,0]:
return 1
if n in memo:
return memo[n]
value = n*fact(n-1)
memo[n] = value
return value
def ncr(n, k):
"""
Choose k elements from a set of n elements - n must be larger than or equal to k
:param n: int
:param k: int
:rtype: int
"""
return factorial(n)/(factorial(k)*factorial(n-k))
時間を比較する場合
from scipy.special import comb
%timeit comb(100,48)
>>> 100000 loops, best of 3: 6.78 µs per loop
%timeit ncr(100,48)
>>> 1000000 loops, best of 3: 1.39 µs per loop
Nが20より大きい場合、直接計算式は大きな整数を生成します。
したがって、さらに別の応答：
from math import factorial
binomial = lambda n,r: reduce(long.__mul__, range(n-r, n+1), 1L) // factorial(r)
短く、迅速で効率的です。
これは、組み込みのメモデコレータを使用した@ killerT2333コードです。
from functools import lru_cache
@lru_cache()
def factorial(n):
"""
Calculate the factorial of an input using memoization
:param n: int
:rtype value: int
"""
return 1 if n in (1, 0) else n * factorial(n-1)
@lru_cache()
def ncr(n, k):
"""
Choose k elements from a set of n elements,
n must be greater than or equal to k.
:param n: int
:param k: int
:rtype: int
"""
return factorial(n) / (factorial(k) * factorial(n - k))
print(ncr(6, 3))
Pythonで配布される標準ライブラリのみを使用：
import itertools
def nCk(n, k):
return len(list(itertools.combinations(range(n), k)))
Sympyを使えば簡単です。
import sympy
comb = sympy.binomial(n, r)
Python 3.8を開始すると、標準ライブラリには、二項係数を計算するための math.comb 関数が含まれるようになりました。
math.comb（n、k）
これは、繰り返しなしでn個のアイテムからk個のアイテムを選択する方法の数ですn! / (k! (n - k)!)：
import math
math.comb(10, 5) # 252
この機能は非常に最適化されています。
def nCk(n,k):
m=0
if k==0:
m=1
if k==1:
m=n
if k>=2:
num,dem,op1,op2=1,1,k,n
while(op1>=1):
num*=op2
dem*=op1
op1-=1
op2-=1
m=num//dem
return m
それはおそらく、かなり大きな入力に対して純粋なpythonでできる限り高速です：
def choose(n, k):
if k == n: return 1
if k > n: return 0
d, q = max(k, n-k), min(k, n-k)
num = 1
for n in xrange(d+1, n+1): num *= n
denom = 1
for d in xrange(1, q+1): denom *= d
return num / denom