translate

Author: hsiangjenli

library/itertools.po

@@ -1988,83 +1988,79 @@ msgstr ""
 "from operator import itemgetter, getitem, mul, neg\n"
 "\n"
 "def take(n, iterable):\n"
-"    \"Return first n items of the iterable as a list.\"\n"
+"    \"回傳可疊代物件的前 n 個元素為串列。\"\n"
 "    return list(islice(iterable, n))\n"
 "\n"
 "def prepend(value, iterable):\n"
-"    \"Prepend a single value in front of an iterable.\"\n"
+"    \"在可疊代物件前插入單一值。\"\n"
 "    # prepend(1, [2, 3, 4]) → 1 2 3 4\n"
 "    return chain([value], iterable)\n"
 "\n"
 "def tabulate(function, start=0):\n"
-"    \"Return function(0), function(1), ...\"\n"
+"    \"回傳 function(0), function(1), ...\"\n"
 "    return map(function, count(start))\n"
 "\n"
 "def repeatfunc(function, times=None, *args):\n"
-"    \"Repeat calls to a function with specified arguments.\"\n"
+"    \"重複呼叫一個帶指定引數的函式。\"\n"
 "    if times is None:\n"
 "        return starmap(function, repeat(args))\n"
 "    return starmap(function, repeat(args, times))\n"
 "\n"
 "def flatten(list_of_lists):\n"
-"    \"Flatten one level of nesting.\"\n"
+"    \"將巢狀結構攤平一層。\"\n"
 "    return chain.from_iterable(list_of_lists)\n"
 "\n"
 "def ncycles(iterable, n):\n"
-"    \"Returns the sequence elements n times.\"\n"
+"    \"回傳序列的元素重複 n 次。\"\n"
 "    return chain.from_iterable(repeat(tuple(iterable), n))\n"
 "\n"
 "def loops(n):\n"
-"    \"Loop n times. Like range(n) but without creating integers.\"\n"
+"    \"執行 n 次的迴圈。類似 range(n) 但不建立整數序列。\"\n"
 "    # for _ in loops(100): ...\n"
 "    return repeat(None, n)\n"
 "\n"
 "def tail(n, iterable):\n"
-"    \"Return an iterator over the last n items.\"\n"
+"    \"回傳一個疊代器，疊代最後 n 個元素。\"\n"
 "    # tail(3, 'ABCDEFG') → E F G\n"
 "    return iter(deque(iterable, maxlen=n))\n"
 "\n"
 "def consume(iterator, n=None):\n"
-"    \"Advance the iterator n-steps ahead. If n is None, consume entirely.\"\n"
-"    # Use functions that consume iterators at C speed.\n"
+"    \"將疊代器往前推進 n 步。如果 n 為 None，則完全消耗。\"\n"
+"    # 使用以 C 語言的速度消耗疊代器的函式。\n"
 "    if n is None:\n"
 "        deque(iterator, maxlen=0)\n"
 "    else:\n"
 "        next(islice(iterator, n, n), None)\n"
 "\n"
 "def nth(iterable, n, default=None):\n"
-"    \"Returns the nth item or a default value.\"\n"
+"    \"回傳第 n 個元素或預設值。\"\n"
 "    return next(islice(iterable, n, None), default)\n"
 "\n"
 "def quantify(iterable, predicate=bool):\n"
-"    \"Given a predicate that returns True or False, count the True results."
-"\"\n"
+"    \"給定一個回傳 True 或 False 的判斷函式，計算為 True 的結果。\"\n"
 "    return sum(map(predicate, iterable))\n"
 "\n"
 "def first_true(iterable, default=False, predicate=None):\n"
-"    \"Returns the first true value or the *default* if there is no true "
-"value.\"\n"
+"    \"回傳第一個為 true 的值，若無則回傳*預設值*。\"\n"
 "    # first_true([a,b,c], x) → a or b or c or x\n"
 "    # first_true([a,b], x, f) → a if f(a) else b if f(b) else x\n"
 "    return next(filter(predicate, iterable), default)\n"
 "\n"
 "def all_equal(iterable, key=None):\n"
-"    \"Returns True if all the elements are equal to each other.\"\n"
+"    \"回傳 True，如果所有元素兩兩相等。\"\n"
 "    # all_equal('4٤௪౪໔', key=int) → True\n"
 "    return len(take(2, groupby(iterable, key))) <= 1\n"
 "\n"
 "def unique_justseen(iterable, key=None):\n"
-"    \"Yield unique elements, preserving order. Remember only the element "
-"just seen.\"\n"
+"    \"產生唯一的元素，並保留原始順序。只記住剛看見的元素。\"\n"
 "    # unique_justseen('AAAABBBCCDAABBB') → A B C D A B\n"
 "    # unique_justseen('ABBcCAD', str.casefold) → A B c A D\n"
 "    if key is None:\n"
 "        return map(itemgetter(0), groupby(iterable))\n"
 "    return map(next, map(itemgetter(1), groupby(iterable, key)))\n"
 "\n"
 "def unique_everseen(iterable, key=None):\n"
-"    \"Yield unique elements, preserving order. Remember all elements ever "
-"seen.\"\n"
+"    \"產生唯一的元素，並保留原始順序。記住所有曾見過的元素。\"\n"
 "    # unique_everseen('AAAABBBCCDAABBB') → A B C D\n"
 "    # unique_everseen('ABBcCAD', str.casefold) → A B c D\n"
 "    seen = set()\n"
@@ -2080,13 +2076,13 @@ msgstr ""
 "                yield element\n"
 "\n"
 "def unique(iterable, key=None, reverse=False):\n"
-"   \"Yield unique elements in sorted order. Supports unhashable inputs.\"\n"
+"   \"產生排序後的不重複元素。支援不可雜湊的輸入。\"\n"
 "   # unique([[1, 2], [3, 4], [1, 2]]) → [1, 2] [3, 4]\n"
 "   sequenced = sorted(iterable, key=key, reverse=reverse)\n"
 "   return unique_justseen(sequenced, key=key)\n"
 "\n"
 "def sliding_window(iterable, n):\n"
-"    \"Collect data into overlapping fixed-length chunks or blocks.\"\n"
+"    \"將資料收集成重疊的固定長度區段或區塊。\"\n"
 "    # sliding_window('ABCDEFG', 4) → ABCD BCDE CDEF DEFG\n"
 "    iterator = iter(iterable)\n"
 "    window = deque(islice(iterator, n - 1), maxlen=n)\n"
@@ -2095,7 +2091,7 @@ msgstr ""
 "        yield tuple(window)\n"
 "\n"
 "def grouper(iterable, n, *, incomplete='fill', fillvalue=None):\n"
-"    \"Collect data into non-overlapping fixed-length chunks or blocks.\"\n"
+"    \"將資料收集成不重疊的固定長度區段或區塊。\"\n"
 "    # grouper('ABCDEFG', 3, fillvalue='x') → ABC DEF Gxx\n"
 "    # grouper('ABCDEFG', 3, incomplete='strict') → ABC DEF ValueError\n"
 "    # grouper('ABCDEFG', 3, incomplete='ignore') → ABC DEF\n"
@@ -2111,22 +2107,22 @@ msgstr ""
 "            raise ValueError('Expected fill, strict, or ignore')\n"
 "\n"
 "def roundrobin(*iterables):\n"
-"    \"Visit input iterables in a cycle until each is exhausted.\"\n"
+"    \"以循環方式依序輸入可疊代物件，直到全部耗盡。\"\n"
 "    # roundrobin('ABC', 'D', 'EF') → A D E B F C\n"
-"    # Algorithm credited to George Sakkis\n"
+"    # 演算法出自 George Sakkis\n"
 "    iterators = map(iter, iterables)\n"
 "    for num_active in range(len(iterables), 0, -1):\n"
 "        iterators = cycle(islice(iterators, num_active))\n"
 "        yield from map(next, iterators)\n"
 "\n"
 "def subslices(seq):\n"
-"    \"Return all contiguous non-empty subslices of a sequence.\"\n"
+"    \"回傳序列的所有連續非空子切片。\"\n"
 "    # subslices('ABCD') → A AB ABC ABCD B BC BCD C CD D\n"
 "    slices = starmap(slice, combinations(range(len(seq) + 1), 2))\n"
 "    return map(getitem, repeat(seq), slices)\n"
 "\n"
 "def iter_index(iterable, value, start=0, stop=None):\n"
-"    \"Return indices where a value occurs in a sequence or iterable.\"\n"
+"    \"回傳在序列或可疊代物件中某值出現的索引位置。\"\n"
 "    # iter_index('AABCADEAF', 'A') → 0 1 4 7\n"
 "    seq_index = getattr(iterable, 'index', None)\n"
 "    if seq_index is None:\n"
@@ -2143,8 +2139,8 @@ msgstr ""
 "                i += 1\n"
 "\n"
 "def iter_except(function, exception, first=None):\n"
-"    \"Convert a call-until-exception interface to an iterator interface.\"\n"
-"    # iter_except(d.popitem, KeyError) → non-blocking dictionary iterator\n"
+"    \"將一個 call-until-exception 轉換為疊代器介面。\"\n"
+"    # iter_except(d.popitem, KeyError) → 非阻塞的字典疊代器\n"
 "    with suppress(exception):\n"
 "        if first is not None:\n"
 "            yield first()\n"
@@ -2282,74 +2278,73 @@ msgid ""
 "    return n"
 msgstr ""
 "def multinomial(*counts):\n"
-"    \"Number of distinct arrangements of a multiset.\"\n"
+"    \"多重集合的不同排列數。\"\n"
 "    # Counter('abracadabra').values() → 5 2 2 1 1\n"
 "    # multinomial(5, 2, 2, 1, 1) → 83160\n"
 "    return prod(map(comb, accumulate(counts), counts))\n"
 "\n"
 "def powerset(iterable):\n"
-"    \"Subsequences of the iterable from shortest to longest.\"\n"
+"    \"來自可疊代物件的子序列，從最短到最長。\"\n"
 "    # powerset([1,2,3]) → () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)\n"
 "    s = list(iterable)\n"
 "    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))\n"
 "\n"
 "def sum_of_squares(iterable):\n"
-"    \"Add up the squares of the input values.\"\n"
+"    \"將輸入值的平方加總。\"\n"
 "    # sum_of_squares([10, 20, 30]) → 1400\n"
 "    return sumprod(*tee(iterable))\n"
 "\n"
 "def reshape(matrix, columns):\n"
-"    \"Reshape a 2-D matrix to have a given number of columns.\"\n"
+"    \"將 2 維矩陣重新塑形為指定的行數。\"\n"
 "    # reshape([(0, 1), (2, 3), (4, 5)], 3) →  (0, 1, 2), (3, 4, 5)\n"
 "    return batched(chain.from_iterable(matrix), columns, strict=True)\n"
 "\n"
 "def transpose(matrix):\n"
-"    \"Swap the rows and columns of a 2-D matrix.\"\n"
+"    \"交換 2 維矩陣的列和行。\"\n"
 "    # transpose([(1, 2, 3), (11, 22, 33)]) → (1, 11) (2, 22) (3, 33)\n"
 "    return zip(*matrix, strict=True)\n"
 "\n"
 "def matmul(m1, m2):\n"
-"    \"Multiply two matrices.\"\n"
+"    \"矩陣相乘。\"\n"
 "    # matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)]) → (49, 80), (41, 60)\n"
 "    n = len(m2[0])\n"
 "    return batched(starmap(sumprod, product(m1, transpose(m2))), n)\n"
 "\n"
 "def convolve(signal, kernel):\n"
-"    \"\"\"Discrete linear convolution of two iterables.\n"
-"    Equivalent to polynomial multiplication.\n"
+"    \"\"\"兩個可疊代物件的離散線性捲積。\n"
+"    等同於多項式相乘。\n"
 "\n"
-"    Convolutions are mathematically commutative; however, the inputs are\n"
-"    evaluated differently.  The signal is consumed lazily and can be\n"
-"    infinite. The kernel is fully consumed before the calculations begin.\n"
+"    在數學上捲積是可交換的；但輸入的處理方式不同。\n"
+"    訊號以惰性方式被讀取，且可以是無限；核心會在計算開始前被全部讀取。\n"
 "\n"
-"    Article:  https://betterexplained.com/articles/intuitive-convolution/\n"
-"    Video:    https://www.youtube.com/watch?v=KuXjwB4LzSA\n"
+"    文章：https://betterexplained.com/articles/intuitive-convolution/\n"
+"    影片：https://www.youtube.com/watch?v=KuXjwB4LzSA\n"
 "    \"\"\"\n"
 "    # convolve([1, -1, -20], [1, -3]) → 1 -4 -17 60\n"
-"    # convolve(data, [0.25, 0.25, 0.25, 0.25]) → Moving average (blur)\n"
-"    # convolve(data, [1/2, 0, -1/2]) → 1st derivative estimate\n"
-"    # convolve(data, [1, -2, 1]) → 2nd derivative estimate\n"
+"    # convolve(data, [0.25, 0.25, 0.25, 0.25]) → 移動平均（模糊）\n"
+"    # convolve(data, [1/2, 0, -1/2]) → 一階導數估計\n"
+"    # convolve(data, [1, -2, 1]) → 二階導數估計\n"
 "    kernel = tuple(kernel)[::-1]\n"
 "    n = len(kernel)\n"
 "    padded_signal = chain(repeat(0, n-1), signal, repeat(0, n-1))\n"
 "    windowed_signal = sliding_window(padded_signal, n)\n"
 "    return map(sumprod, repeat(kernel), windowed_signal)\n"
 "\n"
 "def polynomial_from_roots(roots):\n"
-"    \"\"\"Compute a polynomial's coefficients from its roots.\n"
+"    \"\"\"由多項式的根計算其係數。\n"
 "\n"
-"       (x - 5) (x + 4) (x - 3)  expands to:   x³ -4x² -17x + 60\n"
+"       (x - 5) (x + 4) (x - 3)  展開為:   x³ -4x² -17x + 60\n"
 "    \"\"\"\n"
 "    # polynomial_from_roots([5, -4, 3]) → [1, -4, -17, 60]\n"
 "    factors = zip(repeat(1), map(neg, roots))\n"
 "    return list(reduce(convolve, factors, [1]))\n"
 "\n"
 "def polynomial_eval(coefficients, x):\n"
-"    \"\"\"Evaluate a polynomial at a specific value.\n"
+"    \"\"\"在指定值計算多項式的值。\n"
 "\n"
-"    Computes with better numeric stability than Horner's method.\n"
+"    此方法在數值穩定性上比 Horner 方法更好。\n"
 "    \"\"\"\n"
-"    # Evaluate x³ -4x² -17x + 60 at x = 5\n"
+"    # 計算 x³ -4x² -17x + 60 在 x = 5\n"
 "    # polynomial_eval([1, -4, -17, 60], x=5) → 0\n"
 "    n = len(coefficients)\n"
 "    if not n:\n"
@@ -2358,7 +2353,7 @@ msgstr ""
 "    return sumprod(coefficients, powers)\n"
 "\n"
 "def polynomial_derivative(coefficients):\n"
-"    \"\"\"Compute the first derivative of a polynomial.\n"
+"    \"\"\"計算多項式的一階導數。\n"
 "\n"
 "       f(x)  =  x³ -4x² -17x + 60\n"
 "       f'(x) = 3x² -8x  -17\n"
@@ -2369,7 +2364,7 @@ msgstr ""
 "    return list(map(mul, coefficients, powers))\n"
 "\n"
 "def sieve(n):\n"
-"    \"Primes less than n.\"\n"
+"    \"小於 n 的質數。\"\n"
 "    # sieve(30) → 2 3 5 7 11 13 17 19 23 29\n"
 "    if n > 2:\n"
 "        yield 2\n"
@@ -2379,7 +2374,7 @@ msgstr ""
 "    yield from iter_index(data, 1, start=3)\n"
 "\n"
 "def factor(n):\n"
-"    \"Prime factors of n.\"\n"
+"    \"n 的質因數。\"\n"
 "    # factor(99) → 3 3 11\n"
 "    # factor(1_000_000_000_000_007) → 47 59 360620266859\n"
 "    # factor(1_000_000_000_000_403) → 1000000000000403\n"
@@ -2393,14 +2388,14 @@ msgstr ""
 "        yield n\n"
 "\n"
 "def is_prime(n):\n"
-"    \"Return True if n is prime.\"\n"
+"    \"回傳 True，若 n 為質數。\"\n"
 "    # is_prime(1_000_000_000_000_403) → True\n"
 "    return n > 1 and next(factor(n)) == n\n"
 "\n"
 "def totient(n):\n"
-"    \"Count of natural numbers up to n that are coprime to n.\"\n"
+"    \"計算不大於 n 且與 n 互質的自然數個數。\"\n"
 "    # https://mathworld.wolfram.com/TotientFunction.html\n"
-"    # totient(12) → 4 because len([1, 5, 7, 11]) == 4\n"
+"    # totient(12) → 4 因爲 len([1, 5, 7, 11]) == 4\n"
 "    for prime in set(factor(n)):\n"
 "        n -= n // prime\n"
 "    return n"