"Project-Id-Version: Python 3.16\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-06-11 15:24+0530\n"

"PO-Revision-Date: 2026-06-11 15:35+0530\n"

"Last-Translator: Bhuvansh Kataria <bhuvanshkataria@gmail.com>\n"

"Language-Team: Punjabi (India)\n"

"Language: pa_IN\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

msgid "An Informal Introduction to Python"

msgstr "ਪਾਇਥਨ ਨਾਲ ਇੱਕ ਗੈਰ-ਰਸਮੀ ਜਾਣ-ਪਛਾਣ"

msgid "In the following examples, input and output are distinguished by the presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the example, you must type everything after the prompt, when the prompt appears; lines that do not begin with a prompt are output from the interpreter. Note that a secondary prompt on a line by itself in an example means you must type a blank line; this is used to end a multi-line command."

msgstr "ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਉਦਾਹਰਨਾਂ ਵਿੱਚ input ਅਤੇ output ਨੂੰ prompts (:term:`>>>` ਅਤੇ :term:`...`) ਦੀ ਮੌਜੂਦਗੀ ਜਾਂ ਗੈਰ-ਮੌਜੂਦਗੀ ਰਾਹੀਂ ਵੱਖ ਕੀਤਾ ਗਿਆ ਹੈ। ਉਦਾਹਰਨ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ, ਜਦੋਂ prompt ਦਿਖਾਈ ਦੇਵੇ ਤਾਂ ਉਸ ਤੋਂ ਬਾਅਦ ਆਉਣ ਵਾਲੀ ਹਰ ਚੀਜ਼ ਟਾਈਪ ਕਰੋ। ਜਿਹੜੀਆਂ ਲਾਈਨਾਂ prompt ਨਾਲ ਸ਼ੁਰੂ ਨਹੀਂ ਹੁੰਦੀਆਂ ਉਹ interpreter ਦਾ output ਹਨ। ਧਿਆਨ ਦਿਓ ਕਿ ਜੇਕਰ ਕਿਸੇ ਉਦਾਹਰਨ ਵਿੱਚ ਇੱਕ ਲਾਈਨ ਉੱਤੇ ਸਿਰਫ਼ secondary prompt ਹੋਵੇ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਖਾਲੀ ਲਾਈਨ ਟਾਈਪ ਕਰਨੀ ਪਵੇਗੀ; ਇਸਦਾ ਵਰਤੋਂ multi-line command ਨੂੰ ਖਤਮ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।"

msgid "You can use the \"Copy\" button (it appears in the upper-right corner when hovering over or tapping a code example), which strips prompts and omits output, to copy and paste the input lines into your interpreter."

msgstr "ਤੁਸੀਂ \"Copy\" ਬਟਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ (ਇਹ code example ਉੱਤੇ mouse ਲਿਜਾਣ ਜਾਂ ਉਸਨੂੰ ਛੂਹਣ 'ਤੇ ਉੱਪਰ ਸੱਜੇ ਕੋਨੇ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ)। ਇਹ prompts ਅਤੇ output ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ input ਲਾਈਨਾਂ ਨੂੰ ਆਪਣੇ interpreter ਵਿੱਚ copy-paste ਕਰ ਸਕੋ।"

msgid "Many of the examples in this manual, even those entered at the interactive prompt, include comments. Comments in Python start with the hash character, ``#``, and extend to the end of the physical line. A comment may appear at the start of a line or following whitespace or code, but not within a string literal. A hash character within a string literal is just a hash character. Since comments are to clarify code and are not interpreted by Python, they may be omitted when typing in examples."

msgstr "ਇਸ ਮੈਨੁਅਲ ਦੀਆਂ ਕਈ ਉਦਾਹਰਨਾਂ, ਇੱਥੋਂ ਤੱਕ ਕਿ interactive prompt ਵਿੱਚ ਦਿੱਤੀਆਂ ਉਦਾਹਰਨਾਂ ਵੀ, comments ਸ਼ਾਮਲ ਕਰਦੀਆਂ ਹਨ। ਪਾਇਥਨ ਵਿੱਚ comment hash ਚਿੰਨ੍ਹ ``#`` ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਲਾਈਨ ਦੇ ਅੰਤ ਤੱਕ ਚੱਲਦਾ ਹੈ। Comment ਲਾਈਨ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਜਾਂ whitespace ਜਾਂ code ਤੋਂ ਬਾਅਦ ਆ ਸਕਦਾ ਹੈ, ਪਰ string literal ਦੇ ਅੰਦਰ ਨਹੀਂ। String literal ਦੇ ਅੰਦਰ ਮੌਜੂਦ hash ਚਿੰਨ੍ਹ ਸਿਰਫ਼ ਇੱਕ ਆਮ hash ਚਿੰਨ੍ਹ ਹੁੰਦਾ ਹੈ। ਕਿਉਂਕਿ comments code ਨੂੰ ਸਮਝਾਉਣ ਲਈ ਹੁੰਦੇ ਹਨ ਅਤੇ ਪਾਇਥਨ ਦੁਆਰਾ ਵਿਆਖਿਆ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ, ਇਸ ਲਈ ਉਦਾਹਰਨਾਂ ਟਾਈਪ ਕਰਦੇ ਸਮੇਂ ਇਨ੍ਹਾਂ ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।"

msgid "Some examples::"

msgstr "ਕੁਝ ਉਦਾਹਰਨਾਂ::"

msgid "# this is the first comment\n"

msgstr "# this is the first comment\n"

msgid "Using Python as a Calculator"

msgstr "ਕੈਲਕੂਲੇਟਰ ਵਜੋਂ ਪਾਇਥਨ ਦੀ ਵਰਤੋਂ"

msgid "Let's try some simple Python commands. Start the interpreter and wait for the primary prompt, ``>>>``. (It shouldn't take long.)"

msgstr "ਆਓ ਕੁਝ ਸਧਾਰਣ ਪਾਇਥਨ ਕਮਾਂਡਾਂ ਅਜ਼ਮਾਈਏ। ਇੰਟਰਪ੍ਰੀਟਰ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਮੁੱਖ ਪ੍ਰੌਮਪਟ ``>>>`` ਦੀ ਉਡੀਕ ਕਰੋ। (ਇਸ ਵਿੱਚ ਜ਼ਿਆਦਾ ਸਮਾਂ ਨਹੀਂ ਲੱਗਣਾ ਚਾਹੀਦਾ।)"

msgid "Numbers"

msgstr "ਸੰਖਿਆਵਾਂ"

msgid "The interpreter acts as a simple calculator: you can type an expression into it and it will write the value. Expression syntax is straightforward: the operators ``+``, ``-``, ``*`` and ``/`` can be used to perform arithmetic; parentheses (``()``) can be used for grouping. For example::"

msgstr "ਇੰਟਰਪ੍ਰੀਟਰ ਇੱਕ ਸਧਾਰਣ ਕੈਲਕੂਲੇਟਰ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ: ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਕੋਈ ਅਭਿਵਿਅੰਜਨਾ (expression) ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ ਇਹ ਉਸਦਾ ਮੁੱਲ ਦਿਖਾਏਗਾ। ਅਭਿਵਿਅੰਜਨਾ ਦਾ ਸਿੰਟੈਕਸ ਸਿੱਧਾ ਹੈ: ``+``, ``-``, ``*`` ਅਤੇ ``/`` ਓਪਰੇਟਰ ਗਣਿਤੀ ਕਾਰਵਾਈਆਂ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ; ਕੋਠੇ ``()`` ਸਮੂਹਬੰਦੀ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ::"

msgid ">>> 2 + 2\n"

msgstr ">>> 2 + 2\n"

msgid "The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:`float`. We will see more about numeric types later in the tutorial."

msgstr "ਪੂਰਨ ਅੰਕ (ਜਿਵੇਂ ``2``, ``4``, ``20``) ਦੀ ਕਿਸਮ :class:`int` ਹੁੰਦੀ ਹੈ, ਜਦਕਿ ਭਿੰਨ ਭਾਗ ਵਾਲੀਆਂ ਸੰਖਿਆਵਾਂ (ਜਿਵੇਂ ``5.0``, ``1.6``) ਦੀ ਕਿਸਮ :class:`float` ਹੁੰਦੀ ਹੈ। ਅਸੀਂ tutorial ਵਿੱਚ ਅੱਗੇ numeric types ਬਾਰੇ ਹੋਰ ਜਾਣਾਂਗੇ।"

msgid "Division (``/``) always returns a float. To do :term:`floor division` and get an integer result you can use the ``//`` operator; to calculate the remainder you can use ``%``::"

msgstr "Division (``/``) ਹਮੇਸ਼ਾਂ ਇੱਕ float ਵਾਪਸ ਕਰਦਾ ਹੈ। :term:`floor division` ਕਰਨ ਅਤੇ ਪੂਰਨ ਅੰਕ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਤੁਸੀਂ ``//`` operator ਵਰਤ ਸਕਦੇ ਹੋ; ਬਾਕੀ (remainder) ਕੱਢਣ ਲਈ ``%`` ਵਰਤ ਸਕਦੇ ਹੋ::"

msgid ">>> 17 / 3 # classic division returns a float\n"

msgstr ">>> 17 / 3 # classic division returns a float\n"

msgid "With Python, it is possible to use the ``**`` operator to calculate powers [#]_::"

msgstr "ਪਾਇਥਨ ਵਿੱਚ ਘਾਤਾਂ (powers) ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ``**`` operator ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ [#]_::"

msgid ">>> 5 ** 2 # 5 squared\n"

msgstr ">>> 5 ** 2 # 5 squared\n"

msgid "The equal sign (``=``) is used to assign a value to a variable. Afterwards, no result is displayed before the next interactive prompt::"

msgstr "ਬਰਾਬਰ ਦਾ ਚਿੰਨ੍ਹ (``=``) ਕਿਸੇ variable ਨੂੰ ਮੁੱਲ ਦੇਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ ਅਗਲੇ interactive prompt ਤੋਂ ਪਹਿਲਾਂ ਕੋਈ ਨਤੀਜਾ ਨਹੀਂ ਦਿਖਾਇਆ ਜਾਂਦਾ::"

msgid ">>> width = 20\n"

msgstr ">>> width = 20\n"

msgid "If a variable is not \"defined\" (assigned a value), trying to use it will give you an error::"

msgstr "ਜੇਕਰ ਕੋਈ variable \"defined\" ਨਹੀਂ ਹੈ (ਅਰਥਾਤ ਉਸਨੂੰ ਕੋਈ ਮੁੱਲ ਨਹੀਂ ਦਿੱਤਾ ਗਿਆ), ਤਾਂ ਉਸਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਗਲਤੀ ਮਿਲੇਗੀ::"

msgid ">>> n # try to access an undefined variable\n"

msgstr ">>> n # try to access an undefined variable\n"

msgid "There is full support for floating point; operators with mixed type operands convert the integer operand to floating point::"

msgstr "Floating point ਸੰਖਿਆਵਾਂ ਲਈ ਪੂਰਾ ਸਮਰਥਨ ਉਪਲਬਧ ਹੈ; ਮਿਲੀ-ਜੁਲੀ ਕਿਸਮਾਂ ਵਾਲੇ operands ਦੇ ਨਾਲ operators ਪੂਰਨ ਅੰਕ operand ਨੂੰ floating point ਵਿੱਚ ਬਦਲ ਦਿੰਦੇ ਹਨ::"

msgid ">>> 4 * 3.75 - 1\n"

msgstr ">>> 4 * 3.75 - 1\n"

msgid "In interactive mode, the last printed expression is assigned to the variable ``_``. This means that when you are using Python as a desk calculator, it is somewhat easier to continue calculations, for example::"

msgstr "Interactive mode ਵਿੱਚ, ਆਖਰੀ ਛਪੀ ਹੋਈ expression ਨੂੰ variable ``_`` ਵਿੱਚ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਜਦੋਂ ਤੁਸੀਂ ਪਾਇਥਨ ਨੂੰ ਇੱਕ desk calculator ਵਜੋਂ ਵਰਤ ਰਹੇ ਹੁੰਦੇ ਹੋ, ਤਾਂ ਗਣਨਾਵਾਂ ਜਾਰੀ ਰੱਖਣਾ ਕੁਝ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ::"

msgid ">>> tax = 12.5 / 100\n"

msgstr ">>> tax = 12.5 / 100\n"

msgid "This variable should be treated as read-only by the user. Don't explicitly assign a value to it --- you would create an independent local variable with the same name masking the built-in variable with its magic behavior."

msgstr "ਇਸ variable ਨੂੰ ਵਰਤੋਂਕਾਰ ਵੱਲੋਂ ਕੇਵਲ ਪੜ੍ਹਨਯੋਗ (read-only) ਸਮਝਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸਨੂੰ ਖੁਦ ਕੋਈ ਮੁੱਲ ਨਾ ਦਿਓ --- ਨਹੀਂ ਤਾਂ ਇਸੇ ਨਾਮ ਵਾਲਾ ਇੱਕ ਸੁਤੰਤਰ local variable ਬਣ ਜਾਵੇਗਾ ਜੋ built-in variable ਦੇ ਖਾਸ ਵਿਹਾਰ ਨੂੰ ਓਹਲੇ ਕਰ ਦੇਵੇਗਾ।"

msgid "In addition to :class:`int` and :class:`float`, Python supports other types of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions.Fraction`. Python also has built-in support for :ref:`complex numbers <typesnumeric>`, and uses the ``j`` or ``J`` suffix to indicate the imaginary part (e.g. ``3+5j``)."

msgstr ":class:`int` ਅਤੇ :class:`float` ਤੋਂ ਇਲਾਵਾ, ਪਾਇਥਨ ਹੋਰ ਸੰਖਿਆਤਮਕ ਕਿਸਮਾਂ ਦਾ ਵੀ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ :class:`~decimal.Decimal` ਅਤੇ :class:`~fractions.Fraction`। ਪਾਇਥਨ ਵਿੱਚ :ref:`complex numbers <typesnumeric>` ਲਈ ਵੀ built-in ਸਮਰਥਨ ਹੈ ਅਤੇ ਕਲਪਨਾਤਮਕ ਭਾਗ (imaginary part) ਦਰਸਾਉਣ ਲਈ ``j`` ਜਾਂ ``J`` suffix ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ (ਉਦਾਹਰਨ: ``3+5j``)।"

msgid "Text"

msgstr "ਪਾਠ"

msgid "Python can manipulate text (represented by type :class:`str`, so-called \"strings\") as well as numbers. This includes characters \"``!``\", words \"``rabbit``\", names \"``Paris``\", sentences \"``Got your back.``\", etc. \"``Yay! :)``\". They can be enclosed in single quotes (``'...'``) or double quotes (``\"...\"``) with the same result [#]_."

msgstr "ਪਾਇਥਨ ਸੰਖਿਆਵਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਪਾਠ (text) ਨੂੰ ਵੀ ਸੰਭਾਲ ਸਕਦਾ ਹੈ, ਜਿਸਨੂੰ :class:`str` ਕਿਸਮ ਰਾਹੀਂ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਜਿਸਨੂੰ \"strings\" ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਅੱਖਰ \"``!``\", ਸ਼ਬਦ \"``rabbit``\", ਨਾਮ \"``Paris``\", ਵਾਕ \"``Got your back.``\" ਆਦਿ ਸ਼ਾਮਲ ਹਨ। \"``Yay! :)``\" ਵੀ ਇੱਕ string ਹੈ। ਇਨ੍ਹਾਂ ਨੂੰ single quotes (``'...'``) ਜਾਂ double quotes (``\"...\"``) ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਨਤੀਜਾ ਇੱਕੋ ਜਿਹਾ ਰਹਿੰਦਾ ਹੈ [#]_."

msgid ">>> 'spam eggs' # single quotes\n"

msgstr ">>> 'spam eggs' # single quotes\n"

msgid "To quote a quote, we need to \"escape\" it, by preceding it with ``\\``. Alternatively, we can use the other type of quotation marks::"

msgstr "ਉਧਰਣ ਚਿੰਨ੍ਹਾਂ ਨੂੰ string ਦੇ ਅੰਦਰ ਲਿਖਣ ਲਈ ਸਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ``\\`` ਨਾਲ \"escape\" ਕਰਨਾ ਪੈਂਦਾ ਹੈ। ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਦੂਜੇ ਕਿਸਮ ਦੇ quotation marks ਵੀ ਵਰਤ ਸਕਦੇ ਹਾਂ::"

msgid ">>> 'doesn\\'t' # use \\' to escape the single quote...\n"

msgstr ">>> 'doesn\\'t' # use \\' to escape the single quote...\n"

msgid "In the Python shell, the string definition and output string can look different. The :func:`print` function produces a more readable output, by omitting the enclosing quotes and by printing escaped and special characters::"

msgstr "ਪਾਇਥਨ shell ਵਿੱਚ string ਦੀ ਪਰਿਭਾਸ਼ਾ ਅਤੇ ਦਿਖਾਈ ਗਈ output string ਵੱਖਰੀ ਲੱਗ ਸਕਦੀ ਹੈ। :func:`print` ਫੰਕਸ਼ਨ enclosing quotes ਹਟਾ ਕੇ ਅਤੇ escaped ਜਾਂ special characters ਨੂੰ ਦਰਸਾ ਕੇ ਹੋਰ ਪੜ੍ਹਨਯੋਗ output ਦਿੰਦਾ ਹੈ::"

msgid ">>> s = 'First line.\\nSecond line.' # \\n means newline\n"

msgstr ">>> s = 'First line.\\nSecond line.' # \\n means newline\n"

msgid "If you don't want characters prefaced by ``\\`` to be interpreted as special characters, you can use *raw strings* by adding an ``r`` before the first quote::"

msgstr "ਜੇ ਤੁਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਕਿ ``\\`` ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਅੱਖਰ special characters ਵਜੋਂ ਸਮਝੇ ਜਾਣ, ਤਾਂ ਪਹਿਲੇ quote ਤੋਂ ਪਹਿਲਾਂ ``r`` ਜੋੜ ਕੇ *raw strings* ਵਰਤ ਸਕਦੇ ਹੋ::"

msgid ">>> print('C:\\this\\name') # here \\t means tab, \\n means newline\n"

msgstr ">>> print('C:\\this\\name') # here \\t means tab, \\n means newline\n"

msgid "There is one subtle aspect to raw strings: a raw string may not end in an odd number of ``\\`` characters; see :ref:`the FAQ entry <faq-programming-raw-string-backslash>` for more information and workarounds."

msgstr "Raw strings ਨਾਲ ਇੱਕ ਸੁਖਮ ਗੱਲ ਜੁੜੀ ਹੋਈ ਹੈ: ਕੋਈ raw string ``\\`` ਅੱਖਰਾਂ ਦੀ ਵਿਸਮ (odd) ਗਿਣਤੀ ਨਾਲ ਸਮਾਪਤ ਨਹੀਂ ਹੋ ਸਕਦੀ। ਹੋਰ ਜਾਣਕਾਰੀ ਅਤੇ ਹੱਲਾਂ ਲਈ :ref:`the FAQ entry <faq-programming-raw-string-backslash>` ਵੇਖੋ।"

msgid "String literals can span multiple lines. One way is using triple-quotes: ``\"\"\"...\"\"\"`` or ``'''...'''``. End-of-line characters are automatically included in the string, but it's possible to prevent this by adding a ``\\`` at the end of the line. In the following example, the initial newline is not included::"

msgstr "String literals ਕਈ ਲਾਈਨਾਂ ਵਿੱਚ ਫੈਲ ਸਕਦੀਆਂ ਹਨ। ਇਸਦਾ ਇੱਕ ਤਰੀਕਾ triple-quotes ਵਰਤਣਾ ਹੈ: ``\"\"\"...\"\"\"`` ਜਾਂ ``'''...'''``। End-of-line ਅੱਖਰ ਆਪਣੇ ਆਪ string ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਜਾਂਦੇ ਹਨ, ਪਰ ਲਾਈਨ ਦੇ ਅੰਤ ਵਿੱਚ ``\\`` ਜੋੜ ਕੇ ਇਸਨੂੰ ਰੋਕਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਨ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ newline ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦੀ::"

msgid ">>> print(\"\"\"\\\n"

msgstr ">>> print(\"\"\"\\\n"

msgid "Strings can be concatenated (glued together) with the ``+`` operator, and repeated with ``*``::"

msgstr "Strings ਨੂੰ ``+`` operator ਨਾਲ ਜੋੜਿਆ (concatenate) ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ``*`` ਨਾਲ ਦੁਹਰਾਇਆ ਜਾ ਸਕਦਾ ਹੈ::"

msgid ">>> # 3 times 'un', followed by 'ium'\n"

msgstr ">>> # 3 times 'un', followed by 'ium'\n"

msgid "Two or more *string literals* (i.e. the ones enclosed between quotes) next to each other are automatically concatenated. ::"

msgstr "ਦੋ ਜਾਂ ਵੱਧ *string literals* (ਅਰਥਾਤ quotes ਦੇ ਅੰਦਰ ਲਿਖੀਆਂ strings) ਜੇ ਇਕ ਦੂਜੇ ਦੇ ਕੋਲ ਹੋਣ ਤਾਂ ਉਹ ਆਪਣੇ ਆਪ ਜੋੜ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ::"

msgid ">>> 'Py' 'thon'\n"

msgstr ">>> 'Py' 'thon'\n"

msgid "This feature is particularly useful when you want to break long strings::"

msgstr "ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਉਸ ਵੇਲੇ ਲਾਭਦਾਇਕ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਲੰਬੀਆਂ strings ਨੂੰ ਕਈ ਲਾਈਨਾਂ ਵਿੱਚ ਵੰਡਣਾ ਚਾਹੁੰਦੇ ਹੋ::"

msgid ">>> text = ('Put several strings within parentheses '\n"

msgstr ">>> text = ('Put several strings within parentheses '\n"

msgid "This only works with two literals though, not with variables or expressions::"

msgstr "ਹਾਲਾਂਕਿ ਇਹ ਸਿਰਫ਼ literals ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, variables ਜਾਂ expressions ਨਾਲ ਨਹੀਂ::"

msgid ">>> prefix = 'Py'\n"

msgstr ">>> prefix = 'Py'\n"

msgid "If you want to concatenate variables or a variable and a literal, use ``+``::"

msgstr "ਜੇ ਤੁਸੀਂ variables ਜਾਂ ਕਿਸੇ variable ਅਤੇ literal ਨੂੰ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ``+`` ਵਰਤੋ::"

msgid ">>> prefix + 'thon'\n"

msgstr ">>> prefix + 'thon'\n"

msgid "Strings can be *indexed* (subscripted), with the first character having index 0. There is no separate character type; a character is simply a string of size one::"

msgstr "Strings ਨੂੰ *indexed* (subscripted) ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਪਹਿਲੇ ਅੱਖਰ ਦਾ index 0 ਹੁੰਦਾ ਹੈ। ਕੋਈ ਵੱਖਰੀ character type ਨਹੀਂ ਹੁੰਦੀ; ਇੱਕ character ਅਸਲ ਵਿੱਚ ਲੰਬਾਈ ਇੱਕ ਵਾਲੀ string ਹੀ ਹੁੰਦੀ ਹੈ::"

msgid ">>> word = 'Python'\n"

msgstr ">>> word = 'Python'\n"

msgid "Indices may also be negative numbers, to start counting from the right::"

msgstr "ਸੱਜੇ ਪਾਸੇ ਤੋਂ ਗਿਣਤੀ ਸ਼ੁਰੂ ਕਰਨ ਲਈ indices ਨਕਾਰਾਤਮਕ (negative) ਵੀ ਹੋ ਸਕਦੇ ਹਨ::"

msgid ">>> word[-1] # last character\n"

msgstr ">>> word[-1] # last character\n"

msgid "Note that since -0 is the same as 0, negative indices start from -1."

msgstr "ਧਿਆਨ ਦਿਓ ਕਿ -0 ਅਤੇ 0 ਇੱਕੋ ਹੀ ਹਨ, ਇਸ ਲਈ negative indices ਦੀ ਸ਼ੁਰੂਆਤ -1 ਤੋਂ ਹੁੰਦੀ ਹੈ।"

msgid "In addition to indexing, *slicing* is also supported. While indexing is used to obtain individual characters, *slicing* allows you to obtain a substring::"

msgstr "Indexing ਤੋਂ ਇਲਾਵਾ, *slicing* ਦਾ ਵੀ ਸਮਰਥਨ ਹੈ। ਜਿੱਥੇ indexing ਵੱਖ-ਵੱਖ characters ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਉੱਥੇ *slicing* ਤੁਹਾਨੂੰ substring ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ::"

msgid ">>> word[0:2] # characters from position 0 (included) to 2 (excluded)\n"

msgstr ">>> word[0:2] # characters from position 0 (included) to 2 (excluded)\n"

msgid "Slice indices have useful defaults; an omitted first index defaults to zero, an omitted second index defaults to the size of the string being sliced. ::"

msgstr "Slice indices ਲਈ ਲਾਭਦਾਇਕ ਮੂਲ ਮੁੱਲ ਹੁੰਦੇ ਹਨ; ਜੇ ਪਹਿਲਾ index ਨਾ ਦਿੱਤਾ ਜਾਵੇ ਤਾਂ ਉਹ 0 ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਜੇ ਦੂਜਾ index ਨਾ ਦਿੱਤਾ ਜਾਵੇ ਤਾਂ ਉਹ string ਦੀ ਲੰਬਾਈ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ::"

msgid ">>> word[:2] # character from the beginning to position 2 (excluded)\n"

msgstr ">>> word[:2] # character from the beginning to position 2 (excluded)\n"

msgid "Note how the start is always included, and the end always excluded. This makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"

msgstr "ਧਿਆਨ ਦਿਓ ਕਿ ਸ਼ੁਰੂਆਤੀ ਸਥਾਨ ਹਮੇਸ਼ਾਂ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਅਤੇ ਅੰਤਿਮ ਸਥਾਨ ਹਮੇਸ਼ਾਂ ਬਾਹਰ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਨਾਲ ਇਹ ਯਕੀਨੀ ਬਣਦਾ ਹੈ ਕਿ ``s[:i] + s[i:]`` ਹਮੇਸ਼ਾਂ ``s`` ਦੇ ਬਰਾਬਰ ਰਹੇ::"

msgid ">>> word[:2] + word[2:]\n"

msgstr ">>> word[:2] + word[2:]\n"

msgid "One way to remember how slices work is to think of the indices as pointing *between* characters, with the left edge of the first character numbered 0. Then the right edge of the last character of a string of *n* characters has index *n*, for example::"

msgstr "Slices ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ ਇਹ ਯਾਦ ਰੱਖਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ indices ਨੂੰ ਅੱਖਰਾਂ *ਦੇ ਵਿਚਕਾਰ* ਦਰਸਾਉਣ ਵਾਲੇ ਨਿਸ਼ਾਨਾਂ ਵਜੋਂ ਸੋਚਿਆ ਜਾਵੇ। ਪਹਿਲੇ ਅੱਖਰ ਦੇ ਖੱਬੇ ਕਿਨਾਰੇ ਦਾ index 0 ਹੁੰਦਾ ਹੈ। ਫਿਰ *n* ਅੱਖਰਾਂ ਵਾਲੀ string ਦੇ ਆਖਰੀ ਅੱਖਰ ਦੇ ਸੱਜੇ ਕਿਨਾਰੇ ਦਾ index *n* ਹੁੰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ::"

msgid " +---+---+---+---+---+---+\n"

msgstr " +---+---+---+---+---+---+\n"

msgid "The first row of numbers gives the position of the indices 0...6 in the string; the second row gives the corresponding negative indices. The slice from *i* to *j* consists of all characters between the edges labeled *i* and *j*, respectively."

msgstr "ਅੰਕਾਂ ਦੀ ਪਹਿਲੀ ਕਤਾਰ string ਵਿੱਚ 0...6 indices ਦੀ ਸਥਿਤੀ ਦਿਖਾਉਂਦੀ ਹੈ; ਦੂਜੀ ਕਤਾਰ ਸੰਬੰਧਿਤ negative indices ਦਿਖਾਉਂਦੀ ਹੈ। *i* ਤੋਂ *j* ਤੱਕ ਦੀ slice ਵਿੱਚ *i* ਅਤੇ *j* ਨਾਲ ਨਿਸ਼ਾਨਿਤ ਕਿਨਾਰਿਆਂ ਦੇ ਵਿਚਕਾਰ ਆਉਣ ਵਾਲੇ ਸਾਰੇ ਅੱਖਰ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।"

msgid "For non-negative indices, the length of a slice is the difference of the indices, if both are within bounds. For example, the length of ``word[1:3]`` is 2."

msgstr "ਗੈਰ-ਨਕਾਰਾਤਮਕ indices ਲਈ, ਜੇ ਦੋਵੇਂ ਸੀਮਾ ਦੇ ਅੰਦਰ ਹੋਣ ਤਾਂ slice ਦੀ ਲੰਬਾਈ indices ਦੇ ਅੰਤਰ ਦੇ ਬਰਾਬਰ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, ``word[1:3]`` ਦੀ ਲੰਬਾਈ 2 ਹੈ।"

msgid "Attempting to use an index that is too large will result in an error::"

msgstr "ਬਹੁਤ ਵੱਡਾ index ਵਰਤਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਨਾਲ ਗਲਤੀ (error) ਆਵੇਗੀ::"

msgid ">>> word[42] # the word only has 6 characters\n"

msgstr ">>> word[42] # the word only has 6 characters\n"

msgid "However, out of range slice indexes are handled gracefully when used for slicing::"

msgstr "ਹਾਲਾਂਕਿ slicing ਲਈ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਵਾਲੇ slice indices ਨੂੰ ਸੁਚੱਜੇ ਢੰਗ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ::"

msgid ">>> word[4:42]\n"

msgstr ">>> word[4:42]\n"

msgid "Python strings cannot be changed --- they are :term:`immutable`. Therefore, assigning to an indexed position in the string results in an error::"

msgstr "Python strings ਨੂੰ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ — ਉਹ :term:`immutable` ਹੁੰਦੀਆਂ ਹਨ। ਇਸ ਲਈ string ਦੇ ਕਿਸੇ indexed ਸਥਾਨ ਉੱਤੇ assignment ਕਰਨ ਨਾਲ error ਆਉਂਦੀ ਹੈ::"

msgid ">>> word[0] = 'J'\n"

msgstr ">>> word[0] = 'J'\n"

msgid "If you need a different string, you should create a new one::"

msgstr "ਜੇ ਤੁਹਾਨੂੰ ਵੱਖਰੀ string ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਨਵੀਂ string ਬਣਾਉਣੀ ਚਾਹੀਦੀ ਹੈ::"

msgid ">>> 'J' + word[1:]\n"

msgstr ">>> 'J' + word[1:]\n"

msgid "The built-in function :func:`len` returns the length of a string::"

msgstr "ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ :func:`len` ਸਟਰਿੰਗ ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਕਰਦਾ ਹੈ::"

msgid ">>> s = 'supercalifragilisticexpialidocious'\n"

msgstr ">>> s = 'supercalifragilisticexpialidocious'\n"

msgid ":ref:`textseq`"

msgstr ":ref:`textseq`"

msgid "Strings are examples of *sequence types*, and support the common operations supported by such types."

msgstr "ਸਟਰਿੰਗਾਂ *sequence types* ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਹਨ ਅਤੇ ਅਜਿਹੀਆਂ ਕਿਸਮਾਂ ਦੀਆਂ ਆਮ ਕਾਰਵਾਈਆਂ ਦਾ ਸਮਰਥਨ ਕਰਦੀਆਂ ਹਨ।"

msgid ":ref:`string-methods`"

msgstr ":ref:`string-methods`"

msgid "Strings support a large number of methods for basic transformations and searching."

msgstr "ਸਟਰਿੰਗਾਂ ਮੂਲ ਰੂਪਾਂਤਰਨ ਅਤੇ ਖੋਜ ਲਈ ਬਹੁਤ ਸਾਰੇ ਮੈਥਡਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦੀਆਂ ਹਨ।"

msgid ":ref:`f-strings`"

msgstr ":ref:`f-strings`"

msgid "String literals that have embedded expressions."

msgstr "ਅਜਿਹੀਆਂ ਸਟਰਿੰਗ ਲਿਟਰਲ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਅਭਿਵਿਅੰਜਨਾਵਾਂ ਸ਼ਾਮਲ ਹੁੰਦੀਆਂ ਹਨ।"

msgid ":ref:`formatstrings`"

msgstr ":ref:`formatstrings`"

msgid "Information about string formatting with :meth:`str.format`."

msgstr ":meth:`str.format` ਨਾਲ ਸਟਰਿੰਗ ਫਾਰਮੈਟਿੰਗ ਬਾਰੇ ਜਾਣਕਾਰੀ।"

msgid ":ref:`old-string-formatting`"

msgstr ":ref:`old-string-formatting`"

msgid "The old formatting operations invoked when strings are the left operand of the ``%`` operator are described in more detail here."

msgstr "ਜਦੋਂ ਸਟਰਿੰਗਾਂ ``%`` ਓਪਰੇਟਰ ਦੇ ਖੱਬੇ ਓਪਰੇਂਡ ਵਜੋਂ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਤਾਂ ਪੁਰਾਣੀਆਂ ਫਾਰਮੈਟਿੰਗ ਕਾਰਵਾਈਆਂ ਇੱਥੇ ਹੋਰ ਵਿਸਥਾਰ ਨਾਲ ਸਮਝਾਈਆਂ ਗਈਆਂ ਹਨ।"

msgid "Lists"

msgstr "ਸੂਚੀਆਂ"

msgid "Python knows a number of *compound* data types, used to group together other values. The most versatile is the *list*, which can be written as a list of comma-separated values (items) between square brackets. Lists might contain items of different types, but usually the items all have the same type. ::"

msgstr "ਪਾਇਥਨ ਕਈ *compound* ਡਾਟਾ ਕਿਸਮਾਂ ਨੂੰ ਜਾਣਦਾ ਹੈ, ਜੋ ਹੋਰ ਮੁੱਲਾਂ ਨੂੰ ਇਕੱਠੇ ਸਮੂਹਬੱਧ ਕਰਨ ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਸਭ ਤੋਂ ਲਚਕੀਲੀ *list* ਹੈ, ਜਿਸ ਨੂੰ ਵਰਗ ਕੋਠਿਆਂ ਦੇ ਅੰਦਰ ਕਾਮਿਆਂ ਨਾਲ ਵੱਖ ਕੀਤੀਆਂ ਮੁੱਲਾਂ (items) ਦੀ ਸੂਚੀ ਵਜੋਂ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਸੂਚੀਆਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ items ਹੋ ਸਕਦੇ ਹਨ, ਪਰ ਆਮ ਤੌਰ 'ਤੇ ਸਾਰੇ items ਇੱਕੋ ਕਿਸਮ ਦੇ ਹੁੰਦੇ ਹਨ। ::"

msgid ">>> squares = [1, 4, 9, 16, 25]\n"

msgstr ">>> squares = [1, 4, 9, 16, 25]\n"

msgid "Like strings (and all other built-in :term:`sequence` types), lists can be indexed and sliced::"

msgstr "ਸਟਰਿੰਗਾਂ (ਅਤੇ ਹੋਰ ਸਾਰੇ built-in :term:`sequence` ਕਿਸਮਾਂ) ਦੀ ਤਰ੍ਹਾਂ, ਸੂਚੀਆਂ ਨੂੰ ਵੀ index ਅਤੇ slice ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ::"

msgid ">>> squares[0] # indexing returns the item\n"

msgstr ">>> squares[0] # indexing returns the item\n"

msgid "Lists also support operations like concatenation::"

msgstr "ਸੂਚੀਆਂ concatenation ਵਰਗੀਆਂ ਕਾਰਵਾਈਆਂ ਦਾ ਵੀ ਸਮਰਥਨ ਕਰਦੀਆਂ ਹਨ::"

msgid ">>> squares + [36, 49, 64, 81, 100]\n"

msgstr ">>> squares + [36, 49, 64, 81, 100]\n"

msgid "Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` type, i.e. it is possible to change their content::"

msgstr "ਸਟਰਿੰਗਾਂ ਦੇ ਉਲਟ, ਜੋ :term:`immutable` ਹੁੰਦੀਆਂ ਹਨ, ਸੂਚੀਆਂ ਇੱਕ :term:`mutable` ਕਿਸਮ ਹਨ, ਅਰਥਾਤ ਉਨ੍ਹਾਂ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ::"

msgid ">>> cubes = [1, 8, 27, 65, 125] # something's wrong here\n"

msgstr ">>> cubes = [1, 8, 27, 65, 125] # something's wrong here\n"

msgid "You can also add new items at the end of the list, by using the :meth:`list.append` *method* (we will see more about methods later)::"

msgstr "ਤੁਸੀਂ :meth:`list.append` *method* ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੂਚੀ ਦੇ ਅੰਤ ਵਿੱਚ ਨਵੇਂ items ਵੀ ਜੋੜ ਸਕਦੇ ਹੋ (ਅਸੀਂ methods ਬਾਰੇ ਅੱਗੇ ਹੋਰ ਵੇਖਾਂਗੇ)::"

msgid ">>> cubes.append(216) # add the cube of 6\n"

msgstr ">>> cubes.append(216) # add the cube of 6\n"

msgid "Simple assignment in Python never copies data. When you assign a list to a variable, the variable refers to the *existing list*. Any changes you make to the list through one variable will be seen through all other variables that refer to it.::"

msgstr "ਪਾਇਥਨ ਵਿੱਚ ਸਧਾਰਣ assignment ਕਦੇ ਵੀ ਡਾਟਾ ਦੀ ਕਾਪੀ ਨਹੀਂ ਬਣਾਉਂਦਾ। ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ ਸੂਚੀ ਨੂੰ ਇੱਕ variable ਨਾਲ ਜੋੜਦੇ ਹੋ, ਤਾਂ variable ਮੌਜੂਦਾ *list* ਨੂੰ ਹੀ ਦਰਸਾਉਂਦਾ ਹੈ। ਇੱਕ variable ਰਾਹੀਂ ਕੀਤੀਆਂ ਤਬਦੀਲੀਆਂ ਉਹਨਾਂ ਸਾਰੇ variables ਵਿੱਚ ਦਿਖਾਈ ਦੇਣਗੀਆਂ ਜੋ ਉਸੇ ਸੂਚੀ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ::"

msgid ">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"

msgstr ">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"

msgid "All slice operations return a new list containing the requested elements. This means that the following slice returns a :ref:`shallow copy <shallow_vs_deep_copy>` of the list::"

msgstr "ਸਾਰੀਆਂ slice ਕਾਰਵਾਈਆਂ ਮੰਗੇ ਗਏ ਤੱਤਾਂ ਵਾਲੀ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ। ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹੇਠਾਂ ਦਿੱਤੀ slice ਸੂਚੀ ਦੀ ਇੱਕ :ref:`shallow copy <shallow_vs_deep_copy>` ਵਾਪਸ ਕਰਦੀ ਹੈ::"

msgid ">>> correct_rgba = rgba[:]\n"

msgstr ">>> correct_rgba = rgba[:]\n"

msgid "Assignment to slices is also possible, and this can even change the size of the list or clear it entirely::"

msgstr "Slices ਨੂੰ assignment ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ, ਅਤੇ ਇਸ ਨਾਲ ਸੂਚੀ ਦਾ ਆਕਾਰ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਇਸ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਖਾਲੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ::"

msgid ">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"

msgstr ">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"

msgid "The built-in function :func:`len` also applies to lists::"

msgstr "ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ :func:`len` ਸੂਚੀਆਂ ਉੱਤੇ ਵੀ ਲਾਗੂ ਹੁੰਦਾ ਹੈ::"

msgid ">>> letters = ['a', 'b', 'c', 'd']\n"

msgstr ">>> letters = ['a', 'b', 'c', 'd']\n"

msgid "It is possible to nest lists (create lists containing other lists), for example::"

msgstr "ਸੂਚੀਆਂ ਨੂੰ nested ਬਣਾਉਣਾ (ਅਰਥਾਤ ਹੋਰ ਸੂਚੀਆਂ ਨੂੰ ਸਮੇਟਣ ਵਾਲੀਆਂ ਸੂਚੀਆਂ ਬਣਾਉਣਾ) ਸੰਭਵ ਹੈ, ਉਦਾਹਰਨ ਲਈ::"

msgid ">>> a = ['a', 'b', 'c']\n"

msgstr ">>> a = ['a', 'b', 'c']\n"

msgid "First Steps Towards Programming"

msgstr "ਪਰੋਗ੍ਰਾਮਿੰਗ ਵੱਲ ਪਹਿਲੇ ਕਦਮ"

msgid "Of course, we can use Python for more complicated tasks than adding two and two together. For instance, we can write an initial sub-sequence of the `Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_sequence>`_ as follows::"

msgstr "ਬੇਸ਼ੱਕ, ਅਸੀਂ ਪਾਇਥਨ ਨੂੰ ਸਿਰਫ਼ ਦੋ ਅਤੇ ਦੋ ਜੋੜਨ ਨਾਲੋਂ ਕਾਫ਼ੀ ਜ਼ਿਆਦਾ ਜਟਿਲ ਕੰਮਾਂ ਲਈ ਵਰਤ ਸਕਦੇ ਹਾਂ। ਉਦਾਹਰਨ ਵਜੋਂ, ਅਸੀਂ `Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_sequence>`_ ਦਾ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਉਪ-ਕ੍ਰਮ (sub-sequence) ਇਸ ਤਰ੍ਹਾਂ ਲਿਖ ਸਕਦੇ ਹਾਂ::"

msgid ">>> # Fibonacci series:\n"

msgstr ">>> # Fibonacci series:\n"

msgid "This example introduces several new features."

msgstr "ਇਹ ਉਦਾਹਰਨ ਕਈ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਪੇਸ਼ ਕਰਦੀ ਹੈ।"

msgid "The first line contains a *multiple assignment*: the variables ``a`` and ``b`` simultaneously get the new values 0 and 1. On the last line this is used again, demonstrating that the expressions on the right-hand side are all evaluated first before any of the assignments take place. The right-hand side expressions are evaluated from the left to the right."

msgstr "ਪਹਿਲੀ ਲਾਈਨ ਵਿੱਚ ਇੱਕ *multiple assignment* ਹੈ: variables ``a`` ਅਤੇ ``b`` ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਨਵੇਂ ਮੁੱਲ 0 ਅਤੇ 1 ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ। ਆਖਰੀ ਲਾਈਨ ਵਿੱਚ ਇਸਦੀ ਮੁੜ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ, ਜੋ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ assignment ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਸੱਜੇ ਪਾਸੇ ਵਾਲੀਆਂ ਸਾਰੀਆਂ expressions ਦਾ ਪਹਿਲਾਂ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸੱਜੇ ਪਾਸੇ ਵਾਲੀਆਂ expressions ਦਾ ਮੁਲਾਂਕਣ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਵੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।"

msgid "The :keyword:`while` loop executes as long as the condition (here: ``a < 10``) remains true. In Python, like in C, any non-zero integer value is true; zero is false. The condition may also be a string or list value, in fact any sequence; anything with a non-zero length is true, empty sequences are false. The test used in the example is a simple comparison. The standard comparison operators are written the same as in C: ``<`` (less than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."

msgstr ":keyword:`while` ਲੂਪ ਉਦੋਂ ਤੱਕ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਸ਼ਰਤ (ਇੱਥੇ: ``a < 10``) ਸਹੀ ਰਹਿੰਦੀ ਹੈ। ਪਾਇਥਨ ਵਿੱਚ, C ਦੀ ਤਰ੍ਹਾਂ, ਕੋਈ ਵੀ ਗੈਰ-ਜ਼ੀਰੋ ਪੂਰਨ ਅੰਕ ਮੁੱਲ ਸਹੀ (true) ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ; ਜ਼ੀਰੋ ਗਲਤ (false) ਹੁੰਦਾ ਹੈ। ਸ਼ਰਤ ਇੱਕ string ਜਾਂ list ਮੁੱਲ ਵੀ ਹੋ ਸਕਦੀ ਹੈ; ਅਸਲ ਵਿੱਚ ਕੋਈ ਵੀ sequence। ਜਿਸਦੀ ਲੰਬਾਈ ਗੈਰ-ਜ਼ੀਰੋ ਹੋਵੇ ਉਹ true ਹੁੰਦੀ ਹੈ ਅਤੇ ਖਾਲੀ sequences false ਹੁੰਦੀਆਂ ਹਨ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਵਰਤੀ ਗਈ ਜਾਂਚ ਇੱਕ ਸਧਾਰਣ ਤੁਲਨਾ ਹੈ। ਮਿਆਰੀ comparison operators C ਵਾਂਗ ਹੀ ਲਿਖੇ ਜਾਂਦੇ ਹਨ: ``<`` (ਘੱਟ), ``>`` (ਵੱਧ), ``==`` (ਬਰਾਬਰ), ``<=`` (ਘੱਟ ਜਾਂ ਬਰਾਬਰ), ``>=`` (ਵੱਧ ਜਾਂ ਬਰਾਬਰ) ਅਤੇ ``!=`` (ਅਸਮਾਨ)।"

msgid "The *body* of the loop is *indented*: indentation is Python's way of grouping statements. At the interactive prompt, you have to type a tab or space(s) for each indented line. In practice you will prepare more complicated input for Python with a text editor; all decent text editors have an auto-indent facility. When a compound statement is entered interactively, it must be followed by a blank line to indicate completion (since the parser cannot guess when you have typed the last line). Note that each line within a basic block must be indented by the same amount."

msgstr "ਲੂਪ ਦਾ *body* *indented* ਹੁੰਦਾ ਹੈ: indentation ਪਾਇਥਨ ਵਿੱਚ statements ਨੂੰ ਸਮੂਹਬੱਧ ਕਰਨ ਦਾ ਤਰੀਕਾ ਹੈ। Interactive prompt ਉੱਤੇ, ਹਰ indented ਲਾਈਨ ਲਈ ਤੁਹਾਨੂੰ ਇੱਕ tab ਜਾਂ space(s) ਲਿਖਣੀਆਂ ਪੈਂਦੀਆਂ ਹਨ। ਅਮਲ ਵਿੱਚ, ਤੁਸੀਂ ਪਾਇਥਨ ਲਈ ਵਧੇਰੇ ਜਟਿਲ input ਕਿਸੇ text editor ਦੀ ਮਦਦ ਨਾਲ ਤਿਆਰ ਕਰੋਗੇ; ਲਗਭਗ ਸਾਰੇ ਵਧੀਆ text editors ਵਿੱਚ auto-indent ਦੀ ਸੁਵਿਧਾ ਹੁੰਦੀ ਹੈ। ਜਦੋਂ ਕੋਈ compound statement interactive ਢੰਗ ਨਾਲ ਦਰਜ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਦੇ ਪੂਰਾ ਹੋਣ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਇਸਦੇ ਬਾਅਦ ਇੱਕ ਖਾਲੀ ਲਾਈਨ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ (ਕਿਉਂਕਿ parser ਇਹ ਅੰਦਾਜ਼ਾ ਨਹੀਂ ਲਗਾ ਸਕਦਾ ਕਿ ਤੁਸੀਂ ਆਖਰੀ ਲਾਈਨ ਕਦੋਂ ਲਿਖੀ ਹੈ)। ਧਿਆਨ ਰੱਖੋ ਕਿ ਇੱਕ basic block ਦੇ ਅੰਦਰ ਹਰ ਲਾਈਨ ਇੱਕੋ ਜਿਹੀ ਮਾਤਰਾ ਨਾਲ indented ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।"

msgid "The :func:`print` function writes the value of the argument(s) it is given. It differs from just writing the expression you want to write (as we did earlier in the calculator examples) in the way it handles multiple arguments, floating-point quantities, and strings. Strings are printed without quotes, and a space is inserted between items, so you can format things nicely, like this::"

msgstr ":func:`print` ਫੰਕਸ਼ਨ ਉਸਨੂੰ ਦਿੱਤੇ ਗਏ argument(s) ਦਾ ਮੁੱਲ ਲਿਖਦਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਅਭਿਵਿਅੰਜਨਾ ਲਿਖਣ ਨਾਲੋਂ ਵੱਖਰਾ ਹੈ (ਜਿਵੇਂ ਅਸੀਂ ਪਹਿਲਾਂ ਕੈਲਕੂਲੇਟਰ ਵਾਲੀਆਂ ਉਦਾਹਰਨਾਂ ਵਿੱਚ ਕੀਤਾ ਸੀ), ਕਿਉਂਕਿ ਇਹ ਕਈ arguments, floating-point ਮੁੱਲਾਂ ਅਤੇ strings ਨੂੰ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ। Strings ਬਿਨਾਂ quotes ਦੇ ਛਾਪੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ items ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਖਾਲੀ ਥਾਂ ਜੋੜੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਆਉਟਪੁੱਟ ਨੂੰ ਸੁੰਦਰ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕਰ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ::"

msgid ">>> i = 256*256\n"

msgstr ">>> i = 256*256\n"

msgid "The keyword argument *end* can be used to avoid the newline after the output, or end the output with a different string::"

msgstr "Keyword argument *end* ਦੀ ਵਰਤੋਂ ਆਉਟਪੁੱਟ ਤੋਂ ਬਾਅਦ newline ਤੋਂ ਬਚਣ ਲਈ ਜਾਂ ਆਉਟਪੁੱਟ ਨੂੰ ਕਿਸੇ ਹੋਰ string ਨਾਲ ਸਮਾਪਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ::"

msgid ">>> a, b = 0, 1\n"

msgstr ">>> a, b = 0, 1\n"

msgid "Footnotes"

msgstr "ਫੁੱਟਨੋਟ"

msgid "Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you can use ``(-3)**2``."

msgstr "ਕਿਉਂਕਿ ``**`` ਦੀ precedence ``-`` ਨਾਲੋਂ ਵੱਧ ਹੈ, ਇਸ ਲਈ ``-3**2`` ਨੂੰ ``-(3**2)`` ਵਜੋਂ ਸਮਝਿਆ ਜਾਵੇਗਾ ਅਤੇ ਨਤੀਜਾ ``-9`` ਆਵੇਗਾ। ਇਸ ਤੋਂ ਬਚਣ ਅਤੇ ``9`` ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਤੁਸੀਂ ``(-3)**2`` ਵਰਤ ਸਕਦੇ ਹੋ।"

msgid "Unlike other languages, special characters such as ``\\n`` have the same meaning with both single (``'...'``) and double (``\"...\"``) quotes. The only difference between the two is that within single quotes you don't need to escape ``\"`` (but you have to escape ``\\'``) and vice versa."

msgstr "ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਵੱਖਰਾ, ``\\n`` ਵਰਗੇ special characters ਦਾ ਅਰਥ single (``'...'``) ਅਤੇ double (``\"...\"``) quotes ਦੋਵਾਂ ਵਿੱਚ ਇੱਕੋ ਜਿਹਾ ਹੁੰਦਾ ਹੈ। ਦੋਵਾਂ ਵਿੱਚ ਕੇਵਲ ਇਹ ਫਰਕ ਹੈ ਕਿ single quotes ਦੇ ਅੰਦਰ ਤੁਹਾਨੂੰ ``\"`` ਨੂੰ escape ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ (ਪਰ ``\\'`` ਨੂੰ ਕਰਨਾ ਪੈਂਦਾ ਹੈ), ਅਤੇ double quotes ਵਿੱਚ ਇਸਦਾ ਉਲਟ ਹੁੰਦਾ ਹੈ।"

msgid "# (hash)"

msgstr "# (ਹੈਸ਼)"

msgid "comment"

msgstr "ਟਿੱਪਣੀ"