python-docs-pl/library/random.po at 3.9 · python/python-docs-pl

542 lines (448 loc) · 18.8 KB
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# Translators:
# Maciej Olko <maciej.olko@gmail.com>, 2020
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 05:02+0000\n"
"PO-Revision-Date: 2017-02-16 23:24+0000\n"
"Last-Translator: Maciej Olko <maciej.olko@gmail.com>, 2020\n"
"Language-Team: Polish (https://www.transifex.com/python-doc/teams/5390/pl/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pl\n"
"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "
"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "
"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"
msgid ":mod:`random` --- Generate pseudo-random numbers"
msgid "**Source code:** :source:`Lib/random.py`"
"This module implements pseudo-random number generators for various "
"distributions."
"For integers, there is uniform selection from a range. For sequences, there "
"is uniform selection of a random element, a function to generate a random "
"permutation of a list in-place, and a function for random sampling without "
"replacement."
"On the real line, there are functions to compute uniform, normal (Gaussian), "
"lognormal, negative exponential, gamma, and beta distributions. For "
"generating distributions of angles, the von Mises distribution is available."
"Almost all module functions depend on the basic function :func:`.random`, "
"which generates a random float uniformly in the semi-open range [0.0, 1.0).  "
"Python uses the Mersenne Twister as the core generator.  It produces 53-bit "
"precision floats and has a period of 2\\*\\*19937-1.  The underlying "
"implementation in C is both fast and threadsafe.  The Mersenne Twister is "
"one of the most extensively tested random number generators in existence.  "
"However, being completely deterministic, it is not suitable for all "
"purposes, and is completely unsuitable for cryptographic purposes."
"The functions supplied by this module are actually bound methods of a hidden "
"instance of the :class:`random.Random` class.  You can instantiate your own "
"instances of :class:`Random` to get generators that don't share state."
"Class :class:`Random` can also be subclassed if you want to use a different "
"basic generator of your own devising: in that case, override the :meth:"
"`~Random.random`, :meth:`~Random.seed`, :meth:`~Random.getstate`, and :meth:"
"`~Random.setstate` methods. Optionally, a new generator can supply a :meth:"
"`~Random.getrandbits` method --- this allows :meth:`randrange` to produce "
"selections over an arbitrarily large range."
"The :mod:`random` module also provides the :class:`SystemRandom` class which "
"uses the system function :func:`os.urandom` to generate random numbers from "
"sources provided by the operating system."
"The pseudo-random generators of this module should not be used for security "
"purposes.  For security or cryptographic uses, see the :mod:`secrets` module."
"M. Matsumoto and T. Nishimura, \"Mersenne Twister: A 623-dimensionally "
"equidistributed uniform pseudorandom number generator\", ACM Transactions on "
"Modeling and Computer Simulation Vol. 8, No. 1, January pp.3--30 1998."
"`Complementary-Multiply-with-Carry recipe <https://code.activestate.com/"
"recipes/576707/>`_ for a compatible alternative random number generator with "
"a long period and comparatively simple update operations."
msgid "Bookkeeping functions"
msgid "Initialize the random number generator."
"If *a* is omitted or ``None``, the current system time is used.  If "
"randomness sources are provided by the operating system, they are used "
"instead of the system time (see the :func:`os.urandom` function for details "
"on availability)."
msgid "If *a* is an int, it is used directly."
"With version 2 (the default), a :class:`str`, :class:`bytes`, or :class:"
"`bytearray` object gets converted to an :class:`int` and all of its bits are "
"With version 1 (provided for reproducing random sequences from older "
"versions of Python), the algorithm for :class:`str` and :class:`bytes` "
"generates a narrower range of seeds."
"Moved to the version 2 scheme which uses all of the bits in a string seed."
"In the future, the *seed* must be one of the following types: *NoneType*, :"
"class:`int`, :class:`float`, :class:`str`, :class:`bytes`, or :class:"
"`bytearray`."
"Return an object capturing the current internal state of the generator.  "
"This object can be passed to :func:`setstate` to restore the state."
"*state* should have been obtained from a previous call to :func:`getstate`, "
"and :func:`setstate` restores the internal state of the generator to what it "
"was at the time :func:`getstate` was called."
msgid "Functions for bytes"
msgid "Generate *n* random bytes."
"This method should not be used for generating security tokens. Use :func:"
"`secrets.token_bytes` instead."
msgid "Functions for integers"
"Return a randomly selected element from ``range(start, stop, step)``.  This "
"is equivalent to ``choice(range(start, stop, step))``, but doesn't actually "
"build a range object."
"The positional argument pattern matches that of :func:`range`.  Keyword "
"arguments should not be used because the function may use them in unexpected "
":meth:`randrange` is more sophisticated about producing equally distributed "
"values.  Formerly it used a style like ``int(random()*n)`` which could "
"produce slightly uneven distributions."
"Return a random integer *N* such that ``a <= N <= b``.  Alias for "
"``randrange(a, b+1)``."
"Returns a non-negative Python integer with *k* random bits. This method is "
"supplied with the MersenneTwister generator and some other generators may "
"also provide it as an optional part of the API. When available, :meth:"
"`getrandbits` enables :meth:`randrange` to handle arbitrarily large ranges."
msgid "This method now accepts zero for *k*."
msgid "Functions for sequences"
"Return a random element from the non-empty sequence *seq*. If *seq* is "
"empty, raises :exc:`IndexError`."
"Return a *k* sized list of elements chosen from the *population* with "
"replacement. If the *population* is empty, raises :exc:`IndexError`."
"If a *weights* sequence is specified, selections are made according to the "
"relative weights.  Alternatively, if a *cum_weights* sequence is given, the "
"selections are made according to the cumulative weights (perhaps computed "
"using :func:`itertools.accumulate`).  For example, the relative weights "
"``[10, 5, 30, 5]`` are equivalent to the cumulative weights ``[10, 15, 45, "
"50]``.  Internally, the relative weights are converted to cumulative weights "
"before making selections, so supplying the cumulative weights saves work."
"If neither *weights* nor *cum_weights* are specified, selections are made "
"with equal probability.  If a weights sequence is supplied, it must be the "
"same length as the *population* sequence.  It is a :exc:`TypeError` to "
"specify both *weights* and *cum_weights*."
"The *weights* or *cum_weights* can use any numeric type that interoperates "
"with the :class:`float` values returned by :func:`random` (that includes "
"integers, floats, and fractions but excludes decimals).  Behavior is "
"undefined if any weight is negative.  A :exc:`ValueError` is raised if all "
"weights are zero."
"For a given seed, the :func:`choices` function with equal weighting "
"typically produces a different sequence than repeated calls to :func:"
"`choice`.  The algorithm used by :func:`choices` uses floating point "
"arithmetic for internal consistency and speed.  The algorithm used by :func:"
"`choice` defaults to integer arithmetic with repeated selections to avoid "
"small biases from round-off error."
msgid "Raises a :exc:`ValueError` if all weights are zero."
msgid "Shuffle the sequence *x* in place."
"The optional argument *random* is a 0-argument function returning a random "
"float in [0.0, 1.0); by default, this is the function :func:`.random`."
"To shuffle an immutable sequence and return a new shuffled list, use "
"``sample(x, k=len(x))`` instead."
"Note that even for small ``len(x)``, the total number of permutations of *x* "
"can quickly grow larger than the period of most random number generators. "
"This implies that most permutations of a long sequence can never be "
"generated.  For example, a sequence of length 2080 is the largest that can "
"fit within the period of the Mersenne Twister random number generator."
msgid "The optional parameter *random*."
"Return a *k* length list of unique elements chosen from the population "
"sequence or set. Used for random sampling without replacement."
"Returns a new list containing elements from the population while leaving the "
"original population unchanged.  The resulting list is in selection order so "
"that all sub-slices will also be valid random samples.  This allows raffle "
"winners (the sample) to be partitioned into grand prize and second place "
"winners (the subslices)."
"Members of the population need not be :term:`hashable` or unique.  If the "
"population contains repeats, then each occurrence is a possible selection in "
"the sample."
"Repeated elements can be specified one at a time or with the optional "
"keyword-only *counts* parameter.  For example, ``sample(['red', 'blue'], "
"counts=[4, 2], k=5)`` is equivalent to ``sample(['red', 'red', 'red', 'red', "
"'blue', 'blue'], k=5)``."
"To choose a sample from a range of integers, use a :func:`range` object as "
"an argument.  This is especially fast and space efficient for sampling from "
"a large population:  ``sample(range(10000000), k=60)``."
"If the sample size is larger than the population size, a :exc:`ValueError` "
"is raised."
msgid "Added the *counts* parameter."
"In the future, the *population* must be a sequence.  Instances of :class:"
"`set` are no longer supported.  The set must first be converted to a :class:"
"`list` or :class:`tuple`, preferably in a deterministic order so that the "
"sample is reproducible."
msgid "Real-valued distributions"
"The following functions generate specific real-valued distributions. "
"Function parameters are named after the corresponding variables in the "
"distribution's equation, as used in common mathematical practice; most of "
"these equations can be found in any statistics text."
msgid "Return the next random floating point number in the range [0.0, 1.0)."
"Return a random floating point number *N* such that ``a <= N <= b`` for ``a "
"<= b`` and ``b <= N <= a`` for ``b < a``."
"The end-point value ``b`` may or may not be included in the range depending "
"on floating-point rounding in the equation ``a + (b-a) * random()``."
"Return a random floating point number *N* such that ``low <= N <= high`` and "
"with the specified *mode* between those bounds.  The *low* and *high* bounds "
"default to zero and one.  The *mode* argument defaults to the midpoint "
"between the bounds, giving a symmetric distribution."
"Beta distribution.  Conditions on the parameters are ``alpha > 0`` and "
"``beta > 0``. Returned values range between 0 and 1."
"Exponential distribution.  *lambd* is 1.0 divided by the desired mean.  It "
"should be nonzero.  (The parameter would be called \"lambda\", but that is a "
"reserved word in Python.)  Returned values range from 0 to positive infinity "
"if *lambd* is positive, and from negative infinity to 0 if *lambd* is "
"negative."
"Gamma distribution.  (*Not* the gamma function!)  Conditions on the "
"parameters are ``alpha > 0`` and ``beta > 0``."
msgid "The probability distribution function is::"
"Gaussian distribution.  *mu* is the mean, and *sigma* is the standard "
"deviation.  This is slightly faster than the :func:`normalvariate` function "
"defined below."
"Multithreading note:  When two threads call this function simultaneously, it "
"is possible that they will receive the same return value.  This can be "
"avoided in three ways. 1) Have each thread use a different instance of the "
"random number generator. 2) Put locks around all calls. 3) Use the slower, "
"but thread-safe :func:`normalvariate` function instead."
"Log normal distribution.  If you take the natural logarithm of this "
"distribution, you'll get a normal distribution with mean *mu* and standard "
"deviation *sigma*.  *mu* can have any value, and *sigma* must be greater "
"than zero."
"Normal distribution.  *mu* is the mean, and *sigma* is the standard "
"deviation."
"*mu* is the mean angle, expressed in radians between 0 and 2\\*\\ *pi*, and "
"*kappa* is the concentration parameter, which must be greater than or equal "
"to zero.  If *kappa* is equal to zero, this distribution reduces to a "
"uniform random angle over the range 0 to 2\\*\\ *pi*."
msgid "Pareto distribution.  *alpha* is the shape parameter."
"Weibull distribution.  *alpha* is the scale parameter and *beta* is the "
"shape parameter."
msgid "Alternative Generator"
"Class that implements the default pseudo-random number generator used by "
"the :mod:`random` module."
"In the future, the *seed* must be one of the following types: :class:"
"`NoneType`, :class:`int`, :class:`float`, :class:`str`, :class:`bytes`, or :"
"class:`bytearray`."
"Class that uses the :func:`os.urandom` function for generating random "
"numbers from sources provided by the operating system. Not available on all "
"systems. Does not rely on software state, and sequences are not "
"reproducible. Accordingly, the :meth:`seed` method has no effect and is "
"ignored. The :meth:`getstate` and :meth:`setstate` methods raise :exc:"
"`NotImplementedError` if called."
msgid "Notes on Reproducibility"
"Sometimes it is useful to be able to reproduce the sequences given by a "
"pseudo-random number generator.  By re-using a seed value, the same sequence "
"should be reproducible from run to run as long as multiple threads are not "
"Most of the random module's algorithms and seeding functions are subject to "
"change across Python versions, but two aspects are guaranteed not to change:"
"If a new seeding method is added, then a backward compatible seeder will be "
"The generator's :meth:`~Random.random` method will continue to produce the "
"same sequence when the compatible seeder is given the same seed."
msgid "Examples"
msgstr "Przykłady"
msgid "Basic examples::"
msgid "Simulations::"
"Example of `statistical bootstrapping <https://en.wikipedia.org/wiki/"
"Bootstrapping_(statistics)>`_ using resampling with replacement to estimate "
"a confidence interval for the mean of a sample::"
"Example of a `resampling permutation test <https://en.wikipedia.org/wiki/"
"Resampling_(statistics)#Permutation_tests>`_ to determine the statistical "
"significance or `p-value <https://en.wikipedia.org/wiki/P-value>`_ of an "
"observed difference between the effects of a drug versus a placebo::"
"Simulation of arrival times and service deliveries for a multiserver queue::"
"`Statistics for Hackers <https://www.youtube.com/watch?v=Iq9DzN6mvYA>`_ a "
"video tutorial by `Jake Vanderplas <https://us.pycon.org/2016/speaker/"
"profile/295/>`_ on statistical analysis using just a few fundamental "
"concepts including simulation, sampling, shuffling, and cross-validation."
"`Economics Simulation <http://nbviewer.jupyter.org/url/norvig.com/ipython/"
"Economics.ipynb>`_ a simulation of a marketplace by `Peter Norvig <http://"
"norvig.com/bio.html>`_ that shows effective use of many of the tools and "
"distributions provided by this module (gauss, uniform, sample, betavariate, "
"choice, triangular, and randrange)."
"`A Concrete Introduction to Probability (using Python) <http://nbviewer."
"jupyter.org/url/norvig.com/ipython/Probability.ipynb>`_ a tutorial by `Peter "
"Norvig <http://norvig.com/bio.html>`_ covering the basics of probability "
"theory, how to write simulations, and how to perform data analysis using "
msgid "Recipes"
"The default :func:`.random` returns multiples of 2⁻⁵³ in the range *0.0 ≤ x "
"< 1.0*.  All such numbers are evenly spaced and are exactly representable as "
"Python floats.  However, many other representable floats in that interval "
"are not possible selections.  For example, ``0.05954861408025609`` isn't an "
"integer multiple of 2⁻⁵³."
"The following recipe takes a different approach.  All floats in the interval "
"are possible selections.  The mantissa comes from a uniform distribution of "
"integers in the range *2⁵² ≤ mantissa < 2⁵³*.  The exponent comes from a "
"geometric distribution where exponents smaller than *-53* occur half as "
"often as the next larger exponent."
"All :ref:`real valued distributions <real-valued-distributions>` in the "
"class will use the new method::"
"The recipe is conceptually equivalent to an algorithm that chooses from all "
"the multiples of 2⁻¹⁰⁷⁴ in the range *0.0 ≤ x < 1.0*.  All such numbers are "
"evenly spaced, but most have to be rounded down to the nearest representable "
"Python float.  (The value 2⁻¹⁰⁷⁴ is the smallest positive unnormalized float "
"and is equal to ``math.ulp(0.0)``.)"
"`Generating Pseudo-random Floating-Point Values <https://allendowney.com/"
"research/rand/downey07randfloat.pdf>`_ a paper by Allen B. Downey describing "
"ways to generate more fine-grained floats than normally generated by :func:`."
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

random.po

Latest commit

History

random.po

File metadata and controls
