Kira dan jana faktorial, pilih atur dan gabungan dalam Python

Perniagaan

Matematik modul standard untuk fungsi matematik dalam Python boleh digunakan untuk mengira faktorial. SciPy juga mempunyai fungsi untuk mengira jumlah bilangan pilih atur/gabungan.

Modul itertools juga boleh digunakan untuk menjana pilih atur dan kombinasi daripada senarai (tatasusunan), dsb., dan menghitungnya.

Perkara berikut diterangkan di sini, bersama dengan kod sampel.

  • faktorial:math.factorial()
  • Kira jumlah bilangan pilih atur
    • math.factorial()
    • scipy.special.perm()
  • Hasilkan dan hitungkan pilih atur daripada senarai:itertools.permutations()
  • Kira jumlah bilangan gabungan
    • math.factorial()
    • scipy.special.comb()
    • Bagaimana untuk tidak menggunakan math.faktorial()
  • Hasilkan dan hitungkan gabungan daripada senarai:itertools.combinations()
  • Kira jumlah bilangan gabungan pendua
  • Hasilkan dan hitung gabungan pendua daripada senarai:itertools.combinations_with_replacement()

Sebagai contoh penggunaan pilih atur, perkara berikut juga dijelaskan.

  • Buat anagram daripada rentetan

Jika anda ingin menjana gabungan elemen berbilang penyenaraian dan bukannya satu penyenaraian, gunakan itertools.product() dalam modul itertools.

faktorial:math.factorial()

Modul matematik menyediakan fungsi faktorial() yang mengembalikan faktorial.

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

Nilai negatif bukan integer akan menghasilkan ValueError.

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

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

Kira jumlah bilangan pilih atur

math.factorial()

Pilih atur ialah bilangan kes di mana r dipilih daripada n yang berbeza dan diletakkan dalam satu baris.

Jumlah bilangan pilih atur, p, diperolehi oleh persamaan berikut menggunakan faktorial.

p = n! / (n - r)!

Ia boleh dikira seperti berikut menggunakan fungsi math.faktorial(), yang mengembalikan faktorial. Pengendali ⌘, yang melakukan pembahagian integer, digunakan untuk mengembalikan jenis integer.

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 menyediakan fungsi scipy.special.perm() yang mengembalikan jumlah bilangan pilih atur. Pemasangan SciPy yang berasingan diperlukan. Tersedia daripada versi 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
Argumen ketiga ditetapkan seperti di atas secara lalai dan mengembalikan nombor titik terapung. Ambil perhatian bahawa jika anda ingin mendapatkannya sebagai integer, anda perlu menetapkannya seperti berikut.
exact=True

Ambil perhatian bahawa hanya “import scipy” tidak akan memuatkan modul scipy.special.

Jalankan perm() sebagai “dari scipy.special import perm” seperti dalam contoh di atas, atau laksanakan scipy.special.perm() sebagai “import scipy.special”.

Hasilkan dan hitungkan pilih atur daripada senarai:itertools.permutations()

Bukan sahaja jumlah nombor, malah pilih atur boleh dijana dan dikira daripada senarai (tatasusunan), dsb.

Gunakan fungsi pilih atur() bagi modul itertools.

Melepasi iterable (jenis senarai atau set) sebagai argumen pertama dan bilangan kepingan yang akan dipilih sebagai argumen kedua mengembalikan lelaran untuk pilih atur itu.

import itertools

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

p = itertools.permutations(l, 2)

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

Untuk menghitung kesemuanya, anda boleh menggunakan gelung 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')

Oleh kerana ia adalah lelaran terhingga, ia juga boleh ditukar kepada jenis senarai dengan list().

Apabila bilangan elemen dalam senarai diperoleh dengan len(), ia boleh disahkan bahawa ia sepadan dengan jumlah bilangan pilih atur yang dikira daripada faktorial.

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

Jika hujah kedua ditinggalkan, pilih atur untuk memilih semua elemen dikembalikan.

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

Dalam itertools.permutations(), elemen dirawat berdasarkan kedudukan, bukan nilai. Nilai pendua tidak diambil kira.

l = ['a', 'a']

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

Perkara yang sama berlaku untuk fungsi berikut, yang diterangkan di bawah.

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

Kira jumlah bilangan gabungan

math.factorial()

Bilangan kombinasi ialah bilangan r keping untuk dipilih daripada n keping yang berbeza. Perintah itu tidak dianggap seperti dalam pilih atur.

Jumlah bilangan kombinasi c diperoleh dengan persamaan berikut.

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

Ia boleh dikira seperti berikut menggunakan fungsi math.faktorial(), yang mengembalikan faktorial. Pengendali ⌘, yang melakukan pembahagian integer, digunakan untuk mengembalikan jenis integer.

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 menyediakan fungsi scipy.special.comb() yang mengembalikan jumlah bilangan pilih atur. Pemasangan SciPy yang berasingan diperlukan. Tersedia daripada versi 0.14.0. Ambil perhatian bahawa scipy.misc.comb() tidak melaksanakan pengulangan hujah yang diterangkan di bawah.

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
Seperti scipy.special.perm(), argumen ketiga ditetapkan seperti di atas secara lalai dan mengembalikan nombor titik terapung. Ambil perhatian bahawa jika anda ingin mendapatkannya sebagai integer, anda perlu menetapkannya seperti berikut.
exact=True
Jumlah bilangan gabungan pendua juga boleh diperoleh dengan hujah keempat, pengulangan. Ini diterangkan di bawah.

Sekali lagi, ambil perhatian bahawa hanya “import scipy” tidak akan memuatkan modul scipy.special.

Seperti dalam contoh di atas, laksanakan comb() sebagai “dari scipy.special import comb” atau laksanakan scipy.special.comb() sebagai “import scipy.special”. Perkara yang sama berlaku untuk “scipy.misc”.

Bagaimana untuk tidak menggunakan math.faktorial()

Kaedah lain yang hanya menggunakan perpustakaan standard dan lebih pantas daripada kaedah menggunakan math.factorial() ialah kaedah berikut.

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

Hasilkan dan hitungkan gabungan daripada senarai:itertools.combinations()

Ia adalah mungkin untuk menjana dan menghitung semua kombinasi daripada senarai (tatasusunan), dsb. serta jumlah nombor.

Gunakan fungsi kombinasi() bagi modul itertools.

Melepasi iterable (senarai atau jenis set) sebagai argumen pertama dan bilangan kepingan yang akan dipilih sebagai argumen kedua mengembalikan lelaran untuk gabungan itu.

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

Kira jumlah bilangan gabungan pendua

Bilangan gabungan pendua ialah bilangan kes di mana r dipilih daripada n yang berbeza, membenarkan pendua.

Jumlah bilangan gabungan pendua adalah sama dengan bilangan gabungan untuk memilih (r) daripada (n + r – 1) yang berbeza.

Oleh itu, kita boleh menggunakan fungsi yang ditakrifkan di atas untuk mengira jumlah bilangan gabungan.

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

print(combinations_with_replacement_count(4, 2))
# 10

Dalam “scipy.special.comb()” yang diterangkan di atas, jumlah bilangan gabungan pendua boleh diperoleh dengan menetapkan argumen keempat “repetition=True.
Ambil perhatian bahawa hujah “pengulangan” tidak dilaksanakan dalam “scipy.misc.comb()” dalam versi sebelum “SciPy0.14.0”.

from scipy.special import comb

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

Hasilkan dan hitung gabungan pendua daripada senarai:itertools.combinations_with_replacement()

Ia adalah mungkin untuk menjana dan menghitung semua gabungan pendua daripada senarai (tatasusunan), dsb. serta jumlah nombor.

Gunakan fungsi combinations_with_replacement() dalam modul itertools.

Melepasi iterable (jenis senarai atau set) sebagai argumen pertama dan bilangan bahagian yang akan dipilih sebagai argumen kedua mengembalikan lelaran untuk gabungan bertindih itu.

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

Buat anagram daripada rentetan

Itertools.permutations() memudahkan untuk membuat pilih atur rentetan (anagram).

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

Untuk menggabungkan tuple satu aksara pada satu masa ke dalam rentetan dan menjadikannya dalam senarai, lakukan perkara berikut

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

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

Kaedah join(), yang menggabungkan elemen senarai atau tuple ke dalam rentetan, dan tatatanda pemahaman senarai digunakan.

Copied title and URL