"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-13 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 "More Control Flow Tools"

msgstr "ਕੰਟਰੋਲ ਫਲੋ ਲਈ ਹੋਰ ਸਾਧਨ"

msgid "As well as the :keyword:`while` statement just introduced, Python uses a few more that we will encounter in this chapter."

msgstr "ਹੁਣੇ ਜਾਣ-ਪਛਾਣ ਕਰਵਾਏ ਗਏ :keyword:`while` statement ਤੋਂ ਇਲਾਵਾ, Python ਕੁਝ ਹੋਰ statements ਵੀ ਵਰਤਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨਾਲ ਅਸੀਂ ਇਸ ਅਧਿਆਇ ਵਿੱਚ ਜਾਣੂ ਹੋਵਾਂਗੇ।"

msgid ":keyword:`!if` Statements"

msgstr ":keyword:`!if` ਸਟੇਟਮੈਂਟਾਂ"

msgid "Perhaps the most well-known statement type is the :keyword:`if` statement. For example::"

msgstr "ਸ਼ਾਇਦ ਸਭ ਤੋਂ ਵੱਧ ਜਾਣਿਆ ਜਾਣ ਵਾਲਾ statement ਪ੍ਰਕਾਰ :keyword:`if` statement ਹੈ। ਉਦਾਹਰਨ ਲਈ::"

msgid ">>> x = int(input(\"Please enter an integer: \"))\n"

msgstr ">>> x = int(input(\"Please enter an integer: \"))\n"

msgid "There can be zero or more :keyword:`elif` parts, and the :keyword:`else` part is optional. The keyword ':keyword:`!elif`' is short for 'else if', and is useful to avoid excessive indentation. An :keyword:`!if` ... :keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the ``switch`` or ``case`` statements found in other languages."

msgstr "ਇੱਥੇ ਸ਼ੂਨ੍ਯ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ :keyword:`elif` ਭਾਗ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ :keyword:`else` ਭਾਗ ਵਿਕਲਪਿਕ ਹੈ। ':keyword:`!elif`' keyword, 'else if' ਦਾ ਸੰਖੇਪ ਰੂਪ ਹੈ ਅਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ indentation ਤੋਂ ਬਚਣ ਲਈ ਲਾਭਦਾਇਕ ਹੈ। :keyword:`!if` ... :keyword:`!elif` ... :keyword:`!elif` ... ਦੀ ਲੜੀ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਮਿਲਣ ਵਾਲੇ ``switch`` ਜਾਂ ``case`` statements ਦਾ ਵਿਕਲਪ ਹੈ।"

msgid "If you're comparing the same value to several constants, or checking for specific types or attributes, you may also find the :keyword:`!match` statement useful. For more details see :ref:`tut-match`."

msgstr "ਜੇ ਤੁਸੀਂ ਇੱਕੋ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਕਈ constants ਨਾਲ ਕਰ ਰਹੇ ਹੋ ਜਾਂ ਖਾਸ ਕਿਸਮਾਂ (types) ਜਾਂ attributes ਦੀ ਜਾਂਚ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ :keyword:`!match` statement ਵੀ ਤੁਹਾਡੇ ਲਈ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ। ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ :ref:`tut-match` ਵੇਖੋ।"

msgid ":keyword:`!for` Statements"

msgstr ":keyword:`!for` ਸਟੇਟਮੈਂਟਾਂ"

msgid "The :keyword:`for` statement in Python differs a bit from what you may be used to in C or Pascal. Rather than always iterating over an arithmetic progression of numbers (like in Pascal), or giving the user the ability to define both the iteration step and halting condition (as C), Python's :keyword:`!for` statement iterates over the items of any sequence (a list or a string), in the order that they appear in the sequence. For example (no pun intended):"

msgstr "Python ਵਿੱਚ :keyword:`for` statement ਕੁਝ ਹੱਦ ਤੱਕ ਉਸ ਤਰੀਕੇ ਤੋਂ ਵੱਖਰਾ ਹੈ ਜਿਸ ਨਾਲ ਤੁਸੀਂ C ਜਾਂ Pascal ਵਿੱਚ ਜਾਣੂ ਹੋ ਸਕਦੇ ਹੋ। Pascal ਵਾਂਗ ਸਿਰਫ਼ ਸੰਖਿਆਵਾਂ ਦੀ arithmetic progression ਉੱਤੇ iterate ਕਰਨ ਦੀ ਬਜਾਏ, ਜਾਂ C ਵਾਂਗ iteration step ਅਤੇ ਰੋਕਣ ਦੀ ਸ਼ਰਤ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਣ ਦੀ ਬਜਾਏ, Python ਦਾ :keyword:`!for` statement ਕਿਸੇ ਵੀ sequence (ਜਿਵੇਂ list ਜਾਂ string) ਦੇ items ਉੱਤੇ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ iterate ਕਰਦਾ ਹੈ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ sequence ਵਿੱਚ ਮੌਜੂਦ ਹੁੰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ:"

msgid ">>> # Measure some strings:\n"

msgstr ">>> # Measure some strings:\n"

msgid "Code that modifies a collection while iterating over that same collection can be tricky to get right. Instead, it is usually more straight-forward to loop over a copy of the collection or to create a new collection::"

msgstr "ਉਸੇ collection ਉੱਤੇ iterate ਕਰਦੇ ਸਮੇਂ ਉਸਨੂੰ ਸੋਧਣ ਵਾਲਾ code ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਲਿਖਣਾ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦਾ ਹੈ। ਇਸਦੀ ਬਜਾਏ ਆਮ ਤੌਰ 'ਤੇ collection ਦੀ ਇੱਕ copy ਉੱਤੇ loop ਚਲਾਉਣਾ ਜਾਂ ਇੱਕ ਨਵੀਂ collection ਬਣਾਉਣਾ ਵਧੇਰੇ ਸੌਖਾ ਹੁੰਦਾ ਹੈ::"

msgid "# Create a sample collection\n"

msgstr "# Create a sample collection\n"

msgid "The :func:`range` Function"

msgstr ":func:`range` ਫੰਕਸ਼ਨ"

msgid "If you do need to iterate over a sequence of numbers, the built-in function :func:`range` comes in handy. It generates arithmetic progressions::"

msgstr "ਜੇ ਤੁਹਾਨੂੰ ਸੰਖਿਆਵਾਂ ਦੀ ਕਿਸੇ ਲੜੀ (sequence) ਉੱਤੇ iterate ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇ, ਤਾਂ built-in function :func:`range` ਬਹੁਤ ਕੰਮ ਆਉਂਦਾ ਹੈ। ਇਹ arithmetic progressions ਤਿਆਰ ਕਰਦਾ ਹੈ::"

msgid ">>> for i in range(5):\n"

msgstr ">>> for i in range(5):\n"

msgid "The given end point is never part of the generated sequence; ``range(10)`` generates 10 values, the legal indices for items of a sequence of length 10. It is possible to let the range start at another number, or to specify a different increment (even negative; sometimes this is called the 'step')::"

msgstr "ਦਿੱਤਾ ਗਿਆ ਅੰਤਿਮ ਬਿੰਦੂ (end point) ਕਦੇ ਵੀ ਬਣਾਈ ਗਈ sequence ਦਾ ਹਿੱਸਾ ਨਹੀਂ ਹੁੰਦਾ। ``range(10)`` 10 ਮੁੱਲ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਜੋ ਲੰਬਾਈ 10 ਵਾਲੀ sequence ਦੇ ਵੈਧ indices ਹਨ। range ਨੂੰ ਕਿਸੇ ਹੋਰ ਸੰਖਿਆ ਤੋਂ ਸ਼ੁਰੂ ਕਰਨਾ ਜਾਂ ਵੱਖਰਾ increment ਦੇਣਾ ਵੀ ਸੰਭਵ ਹੈ (ਭਾਵੇਂ ਉਹ ਨਕਾਰਾਤਮਕ ਹੀ ਕਿਉਂ ਨਾ ਹੋਵੇ; ਇਸਨੂੰ ਕਈ ਵਾਰ 'step' ਕਿਹਾ ਜਾਂਦਾ ਹੈ)::"

msgid ">>> list(range(5, 10))\n"

msgstr ">>> list(range(5, 10))\n"

msgid "To iterate over the indices of a sequence, you can combine :func:`range` and :func:`len` as follows::"

msgstr "ਕਿਸੇ sequence ਦੇ indices ਉੱਤੇ iterate ਕਰਨ ਲਈ ਤੁਸੀਂ :func:`range` ਅਤੇ :func:`len` ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਇਕੱਠੇ ਵਰਤ ਸਕਦੇ ਹੋ::"

msgid ">>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n"

msgstr ">>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n"

msgid "In most such cases, however, it is convenient to use the :func:`enumerate` function, see :ref:`tut-loopidioms`."

msgstr "ਹਾਲਾਂਕਿ ਜ਼ਿਆਦਾਤਰ ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਵਿੱਚ :func:`enumerate` function ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਵਧੇਰੇ ਸੁਵਿਧਾਜਨਕ ਹੁੰਦਾ ਹੈ। ਵੇਖੋ :ref:`tut-loopidioms`।"

msgid "A strange thing happens if you just print a range::"

msgstr "ਜੇ ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ range ਨੂੰ print ਕਰੋ ਤਾਂ ਇੱਕ ਦਿਲਚਸਪ ਗੱਲ ਹੁੰਦੀ ਹੈ::"

msgid ">>> range(10)\n"

msgstr ">>> range(10)\n"

msgid "In many ways the object returned by :func:`range` behaves as if it is a list, but in fact it isn't. It is an object which returns the successive items of the desired sequence when you iterate over it, but it doesn't really make the list, thus saving space."

msgstr ":func:`range` ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਗਿਆ object ਕਈ ਤਰੀਕਿਆਂ ਨਾਲ list ਵਾਂਗ ਵਿਹਾਰ ਕਰਦਾ ਹੈ, ਪਰ ਅਸਲ ਵਿੱਚ ਇਹ list ਨਹੀਂ ਹੁੰਦਾ। ਇਹ ਇੱਕ ਅਜਿਹਾ object ਹੈ ਜੋ iterate ਕਰਨ ਸਮੇਂ ਲੋੜੀਂਦੀ sequence ਦੇ items ਇੱਕ-ਇੱਕ ਕਰਕੇ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਪਰ ਇਹ ਪੂਰੀ list ਨਹੀਂ ਬਣਾਉਂਦਾ, ਜਿਸ ਨਾਲ memory ਦੀ ਬਚਤ ਹੁੰਦੀ ਹੈ।"

msgid "We say such an object is :term:`iterable`, that is, suitable as a target for functions and constructs that expect something from which they can obtain successive items until the supply is exhausted. We have seen that the :keyword:`for` statement is such a construct, while an example of a function that takes an iterable is :func:`sum`::"

msgstr "ਅਸੀਂ ਅਜਿਹੇ object ਨੂੰ :term:`iterable` ਕਹਿੰਦੇ ਹਾਂ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਹ ਉਹਨਾਂ functions ਅਤੇ constructs ਲਈ ਉਚਿਤ ਹੁੰਦਾ ਹੈ ਜੋ ਕਿਸੇ ਅਜਿਹੀ ਚੀਜ਼ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹਨ ਜਿਸ ਤੋਂ ਉਹ ਲਗਾਤਾਰ items ਪ੍ਰਾਪਤ ਕਰ ਸਕਣ ਜਦ ਤੱਕ ਉਹ ਸਮਾਪਤ ਨਾ ਹੋ ਜਾਣ। ਅਸੀਂ ਵੇਖ ਚੁੱਕੇ ਹਾਂ ਕਿ :keyword:`for` statement ਅਜਿਹਾ ਹੀ ਇੱਕ construct ਹੈ, ਜਦਕਿ iterable ਨੂੰ argument ਵਜੋਂ ਲੈਣ ਵਾਲੇ function ਦੀ ਇੱਕ ਉਦਾਹਰਨ :func:`sum` ਹੈ::"

msgid ">>> sum(range(4)) # 0 + 1 + 2 + 3\n"

msgstr ">>> sum(range(4)) # 0 + 1 + 2 + 3\n"

msgid "Later we will see more functions that return iterables and take iterables as arguments. In chapter :ref:`tut-structures`, we will discuss :func:`list` in more detail."

msgstr "ਅੱਗੇ ਅਸੀਂ ਹੋਰ ਅਜੇਹੇ functions ਵੇਖਾਂਗੇ ਜੋ iterables ਵਾਪਸ ਕਰਦੇ ਹਨ ਅਤੇ iterables ਨੂੰ arguments ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ। ਅਧਿਆਇ :ref:`tut-structures` ਵਿੱਚ ਅਸੀਂ :func:`list` ਬਾਰੇ ਹੋਰ ਵਿਸਥਾਰ ਨਾਲ ਚਰਚਾ ਕਰਾਂਗੇ।"

msgid ":keyword:`!break` and :keyword:`!continue` Statements"

msgstr ":keyword:`!break` ਅਤੇ :keyword:`!continue` Statements"

msgid "The :keyword:`break` statement breaks out of the innermost enclosing :keyword:`for` or :keyword:`while` loop::"

msgstr ":keyword:`break` statement ਸਭ ਤੋਂ ਅੰਦਰਲੇ :keyword:`for` ਜਾਂ :keyword:`while` loop ਤੋਂ ਤੁਰੰਤ ਬਾਹਰ ਨਿਕਲ ਜਾਂਦੀ ਹੈ::"

msgid ">>> for n in range(2, 10):\n"

msgstr ">>> for n in range(2, 10):\n"

msgid "The :keyword:`continue` statement continues with the next iteration of the loop::"

msgstr ":keyword:`continue` statement loop ਦੀ ਅਗਲੀ iteration ਨਾਲ ਕਾਰਵਾਈ ਜਾਰੀ ਰੱਖਦੀ ਹੈ::"

msgid ">>> for num in range(2, 10):\n"

msgstr ">>> for num in range(2, 10):\n"

msgid ":keyword:`!else` Clauses on Loops"

msgstr "Loops ਉੱਤੇ :keyword:`!else` Clauses"

msgid "In a :keyword:`!for` or :keyword:`!while` loop the :keyword:`!break` statement may be paired with an :keyword:`!else` clause. If the loop finishes without executing the :keyword:`!break`, the :keyword:`!else` clause executes."

msgstr ":keyword:`!for` ਜਾਂ :keyword:`!while` loop ਵਿੱਚ :keyword:`!break` statement ਨੂੰ :keyword:`!else` clause ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਜੇ loop :keyword:`!break` ਨੂੰ ਚਲਾਏ ਬਿਨਾਂ ਸਮਾਪਤ ਹੋ ਜਾਵੇ, ਤਾਂ :keyword:`!else` clause ਚਲਦਾ ਹੈ।"

msgid "In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the loop finishes its final iteration, that is, if no break occurred."

msgstr ":keyword:`for` loop ਵਿੱਚ :keyword:`!else` clause ਉਸ ਵੇਲੇ ਚਲਦਾ ਹੈ ਜਦੋਂ loop ਆਪਣੀ ਆਖਰੀ iteration ਪੂਰੀ ਕਰ ਲੈਂਦਾ ਹੈ, ਅਰਥਾਤ ਜੇ ਕੋਈ break ਨਾ ਆਇਆ ਹੋਵੇ।"

msgid "In a :keyword:`while` loop, it's executed after the loop's condition becomes false."

msgstr ":keyword:`while` loop ਵਿੱਚ ਇਹ loop ਦੀ ਸ਼ਰਤ false ਹੋ ਜਾਣ ਤੋਂ ਬਾਅਦ ਚਲਦਾ ਹੈ।"

msgid "In either kind of loop, the :keyword:`!else` clause is **not** executed if the loop was terminated by a :keyword:`break`. Of course, other ways of ending the loop early, such as a :keyword:`return` or a raised exception, will also skip execution of the :keyword:`else` clause."

msgstr "ਦੋਵੇਂ ਕਿਸਮਾਂ ਦੇ loops ਵਿੱਚ, ਜੇ loop :keyword:`break` ਨਾਲ ਸਮਾਪਤ ਕੀਤਾ ਗਿਆ ਹੋਵੇ ਤਾਂ :keyword:`!else` clause **ਨਹੀਂ** ਚਲਦਾ। ਇਸੇ ਤਰ੍ਹਾਂ, loop ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਖਤਮ ਕਰਨ ਦੇ ਹੋਰ ਤਰੀਕੇ, ਜਿਵੇਂ :keyword:`return` ਜਾਂ exception ਉੱਠਣਾ, ਵੀ :keyword:`else` clause ਨੂੰ ਚਲਣ ਤੋਂ ਰੋਕਦੇ ਹਨ।"

msgid "This is exemplified in the following :keyword:`!for` loop, which searches for prime numbers::"

msgstr "ਇਸਦੀ ਉਦਾਹਰਨ ਹੇਠਾਂ ਦਿੱਤੇ :keyword:`!for` ਲੂਪ ਵਿੱਚ ਵੇਖੀ ਜਾ ਸਕਦੀ ਹੈ, ਜੋ ਅਭਾਜ ਸੰਖਿਆਵਾਂ (prime numbers) ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ::"

msgid ">>> for n in range(2, 10):\n"

msgstr ">>> for n in range(2, 10):\n"

msgid "(Yes, this is the correct code. Look closely: the ``else`` clause belongs to the ``for`` loop, **not** the ``if`` statement.)"

msgstr "(ਹਾਂ, ਇਹ ਬਿਲਕੁਲ ਸਹੀ ਕੋਡ ਹੈ। ਧਿਆਨ ਨਾਲ ਵੇਖੋ: ``else`` clause ``for`` loop ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ, ``if`` statement ਨਾਲ **ਨਹੀਂ**।)"

msgid "One way to think of the else clause is to imagine it paired with the ``if`` inside the loop. As the loop executes, it will run a sequence like if/if/if/else. The ``if`` is inside the loop, encountered a number of times. If the condition is ever true, a ``break`` will happen. If the condition is never true, the ``else`` clause outside the loop will execute."

msgstr "``else`` clause ਨੂੰ ਸਮਝਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਇਸਨੂੰ ਲੂਪ ਦੇ ਅੰਦਰਲੇ ``if`` ਨਾਲ ਜੋੜ ਕੇ ਸੋਚਿਆ ਜਾਵੇ। ਜਦੋਂ ਲੂਪ ਚੱਲਦਾ ਹੈ, ਇਹ if/if/if/else ਵਰਗੀ ਲੜੀ ਚਲਾਉਂਦਾ ਹੈ। ``if`` ਲੂਪ ਦੇ ਅੰਦਰ ਹੁੰਦਾ ਹੈ ਅਤੇ ਕਈ ਵਾਰ ਮਿਲਦਾ ਹੈ। ਜੇ ਸ਼ਰਤ ਕਦੇ ਸੱਚ ਹੋ ਜਾਵੇ ਤਾਂ ``break`` ਚੱਲੇਗਾ। ਜੇ ਸ਼ਰਤ ਕਦੇ ਵੀ ਸੱਚ ਨਾ ਹੋਵੇ, ਤਾਂ ਲੂਪ ਤੋਂ ਬਾਹਰਲਾ ``else`` clause ਚੱਲੇਗਾ।"

msgid "When used with a loop, the ``else`` clause has more in common with the ``else`` clause of a :keyword:`try` statement than it does with that of ``if`` statements: a ``try`` statement's ``else`` clause runs when no exception occurs, and a loop's ``else`` clause runs when no ``break`` occurs. For more on the ``try`` statement and exceptions, see :ref:`tut-handling`."

msgstr "ਜਦੋਂ ``else`` clause ਨੂੰ ਲੂਪ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ :keyword:`try` statement ਦੇ ``else`` clause ਨਾਲ ਵੱਧ ਮਿਲਦਾ ਹੈ, ਨਾ ਕਿ ``if`` statement ਦੇ ``else`` ਨਾਲ। ``try`` statement ਦਾ ``else`` ਉਸ ਵੇਲੇ ਚੱਲਦਾ ਹੈ ਜਦੋਂ ਕੋਈ exception ਨਹੀਂ ਆਉਂਦੀ, ਅਤੇ ਲੂਪ ਦਾ ``else`` ਉਸ ਵੇਲੇ ਚੱਲਦਾ ਹੈ ਜਦੋਂ ਕੋਈ ``break`` ਨਹੀਂ ਹੁੰਦਾ। :keyword:`try` statement ਅਤੇ exceptions ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ :ref:`tut-handling` ਵੇਖੋ।"

msgid ":keyword:`!pass` Statements"

msgstr ":keyword:`!pass` Statements"

msgid "The :keyword:`pass` statement does nothing. It can be used when a statement is required syntactically but the program requires no action. For example::"

msgstr ":keyword:`pass` statement ਕੋਈ ਕੰਮ ਨਹੀਂ ਕਰਦੀ। ਇਸਦੀ ਵਰਤੋਂ ਉਸ ਵੇਲੇ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਦੋਂ syntax ਅਨੁਸਾਰ ਕੋਈ statement ਲਾਜ਼ਮੀ ਹੋਵੇ ਪਰ program ਨੂੰ ਕੋਈ ਕਾਰਵਾਈ ਕਰਨ ਦੀ ਲੋੜ ਨਾ ਹੋਵੇ। ਉਦਾਹਰਨ ਲਈ::"

msgid ">>> while True:\n"

msgstr ">>> while True:\n"

msgid "This is commonly used for creating minimal classes::"

msgstr "ਇਸਦੀ ਵਰਤੋਂ ਆਮ ਤੌਰ 'ਤੇ ਘੱਟੋ-ਘੱਟ (minimal) classes ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ::"

msgid ">>> class MyEmptyClass:\n"

msgstr ">>> class MyEmptyClass:\n"

msgid "Another place :keyword:`pass` can be used is as a place-holder for a function or conditional body when you are working on new code, allowing you to keep thinking at a more abstract level. The :keyword:`!pass` is silently ignored::"

msgstr ":keyword:`pass` ਦੀ ਇੱਕ ਹੋਰ ਵਰਤੋਂ function ਜਾਂ conditional body ਲਈ placeholder ਵਜੋਂ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਨਵਾਂ code ਲਿਖ ਰਹੇ ਹੋ। ਇਹ ਤੁਹਾਨੂੰ ਹੋਰ ਅਮੂਰਤ (abstract) ਪੱਧਰ 'ਤੇ ਸੋਚਦੇ ਰਹਿਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। :keyword:`!pass` ਨੂੰ ਚੁੱਪਚਾਪ ਅਣਡਿੱਠਾ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ::"

msgid ">>> def initlog(*args):\n"

msgstr ">>> def initlog(*args):\n"

msgid "For this last case, many people use the ellipsis literal :code:`...` instead of :code:`pass`. This use has no special meaning to Python, and is not part of the language definition (you could use any constant expression here), but :code:`...` is used conventionally as a placeholder body as well. See :ref:`bltin-ellipsis-object`."

msgstr "ਇਸ ਆਖਰੀ ਸਥਿਤੀ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਲੋਕ :code:`pass` ਦੀ ਥਾਂ ellipsis literal :code:`...` ਵਰਤਦੇ ਹਨ। Python ਵਿੱਚ ਇਸਦਾ ਕੋਈ ਖਾਸ ਅਰਥ ਨਹੀਂ ਹੈ ਅਤੇ ਇਹ ਭਾਸ਼ਾ ਦੀ ਪਰਿਭਾਸ਼ਾ ਦਾ ਹਿੱਸਾ ਵੀ ਨਹੀਂ ਹੈ (ਤੁਸੀਂ ਇੱਥੇ ਕੋਈ ਵੀ constant expression ਵਰਤ ਸਕਦੇ ਹੋ), ਪਰ ਰਵਾਇਤੀ ਤੌਰ 'ਤੇ :code:`...` ਨੂੰ placeholder body ਵਜੋਂ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਵੇਖੋ :ref:`bltin-ellipsis-object`।"

msgid ":keyword:`!match` Statements"

msgstr ":keyword:`!match` Statements"

msgid "A :keyword:`match` statement takes an expression and compares its value to successive patterns given as one or more case blocks. This is superficially similar to a switch statement in C, Java or JavaScript (and many other languages), but it's more similar to pattern matching in languages like Rust or Haskell. Only the first pattern that matches gets executed and it can also extract components (sequence elements or object attributes) from the value into variables. If no case matches, none of the branches is executed."

msgstr ":keyword:`match` statement ਇੱਕ expression ਲੈਂਦੀ ਹੈ ਅਤੇ ਉਸਦੇ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਇੱਕ ਜਾਂ ਵੱਧ case blocks ਵਿੱਚ ਦਿੱਤੇ ਲਗਾਤਾਰ patterns ਨਾਲ ਕਰਦੀ ਹੈ। ਇਹ ਉੱਪਰੀ ਤੌਰ 'ਤੇ C, Java ਜਾਂ JavaScript ਦੀ switch statement ਵਰਗੀ ਲੱਗਦੀ ਹੈ, ਪਰ ਅਸਲ ਵਿੱਚ Rust ਜਾਂ Haskell ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਦੀ pattern matching ਦੇ ਹੋਰ ਨੇੜੇ ਹੈ। ਸਿਰਫ਼ ਪਹਿਲਾ ਮਿਲਦਾ pattern ਹੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹ ਮੁੱਲ ਵਿੱਚੋਂ components (sequence elements ਜਾਂ object attributes) ਨੂੰ variables ਵਿੱਚ ਕੈਪਚਰ ਵੀ ਕਰ ਸਕਦਾ ਹੈ। ਜੇ ਕੋਈ case match ਨਾ ਕਰੇ ਤਾਂ ਕੋਈ ਵੀ branch ਨਹੀਂ ਚਲਦੀ।"

msgid "The simplest form compares a subject value against one or more literals::"

msgstr "ਸਭ ਤੋਂ ਸਰਲ ਰੂਪ ਕਿਸੇ subject value ਦੀ ਤੁਲਨਾ ਇੱਕ ਜਾਂ ਵੱਧ literals ਨਾਲ ਕਰਦਾ ਹੈ::"

msgid ""

msgstr ""

msgid "Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and never fails to match."

msgstr "ਆਖਰੀ block ਉੱਤੇ ਧਿਆਨ ਦਿਓ: \"variable name\" ``_`` ਇੱਕ *wildcard* ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਹਮੇਸ਼ਾਂ match ਕਰ ਜਾਂਦਾ ਹੈ।"

msgid "You can combine several literals in a single pattern using ``|`` (\"or\")::"

msgstr "ਤੁਸੀਂ ``|`` (\"or\") ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ pattern ਵਿੱਚ ਕਈ literals ਨੂੰ ਜੋੜ ਸਕਦੇ ਹੋ::"

msgid ""

msgstr ""

msgid "Patterns can look like unpacking assignments, and can be used to bind variables::"

msgstr "Patterns unpacking assignments ਵਰਗੇ ਦਿਸ ਸਕਦੇ ਹਨ ਅਤੇ variables ਨੂੰ bind ਕਰਨ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ::"

msgid "# point is an (x, y) tuple\n"

msgstr "# point ਇੱਕ (x, y) tuple ਹੈ\n"

msgid "Study that one carefully! The first pattern has two literals, and can be thought of as an extension of the literal pattern shown above. But the next two patterns combine a literal and a variable, and the variable *binds* a value from the subject (``point``). The fourth pattern captures two values, which makes it conceptually similar to the unpacking assignment ``(x, y) = point``."

msgstr "ਇਸ ਉਦਾਹਰਨ ਨੂੰ ਧਿਆਨ ਨਾਲ ਸਮਝੋ! ਪਹਿਲੇ pattern ਵਿੱਚ ਦੋ literals ਹਨ ਅਤੇ ਇਸਨੂੰ ਉੱਪਰ ਦਿਖਾਏ literal pattern ਦੇ ਵਿਸਤਾਰ ਵਜੋਂ ਸਮਝਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਅਗਲੇ ਦੋ patterns ਇੱਕ literal ਅਤੇ ਇੱਕ variable ਨੂੰ ਜੋੜਦੇ ਹਨ, ਅਤੇ variable subject (``point``) ਵਿੱਚੋਂ ਇੱਕ ਮੁੱਲ *bind* ਕਰਦਾ ਹੈ। ਚੌਥਾ pattern ਦੋ ਮੁੱਲਾਂ ਨੂੰ capture ਕਰਦਾ ਹੈ, ਜਿਸ ਕਾਰਨ ਇਹ ਧਾਰਣਾਤਮਕ ਤੌਰ 'ਤੇ unpacking assignment ``(x, y) = point`` ਵਰਗਾ ਹੈ।"

msgid "If you are using classes to structure your data you can use the class name followed by an argument list resembling a constructor, but with the ability to capture attributes into variables::"

msgstr "ਜੇ ਤੁਸੀਂ ਆਪਣੇ data ਨੂੰ ਢਾਂਚਾਬੱਧ ਕਰਨ ਲਈ classes ਵਰਤ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ class name ਤੋਂ ਬਾਅਦ constructor ਵਰਗੀ argument list ਵਰਤ ਸਕਦੇ ਹੋ, ਜਿਸ ਵਿੱਚ attributes ਨੂੰ variables ਵਿੱਚ capture ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਹੁੰਦੀ ਹੈ::"

msgid "class Point:\n"

msgstr "class Point:\n"

msgid "You can use positional parameters with some builtin classes that provide an ordering for their attributes (e.g. dataclasses). You can also define a specific position for attributes in patterns by setting the ``__match_args__`` special attribute in your classes. If it's set to (\"x\", \"y\"), the following patterns are all equivalent (and all bind the ``y`` attribute to the ``var`` variable)::"

msgstr "ਤੁਸੀਂ ਕੁਝ builtin classes (ਜਿਵੇਂ dataclasses) ਨਾਲ positional parameters ਵਰਤ ਸਕਦੇ ਹੋ ਜੋ ਆਪਣੇ attributes ਲਈ ਕ੍ਰਮ ਨਿਰਧਾਰਤ ਕਰਦੀਆਂ ਹਨ। ਤੁਸੀਂ ਆਪਣੀਆਂ classes ਵਿੱਚ ``__match_args__`` special attribute ਸੈੱਟ ਕਰਕੇ patterns ਵਿੱਚ attributes ਦੀ ਖਾਸ position ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ। ਜੇ ਇਸਨੂੰ (\"x\", \"y\") ਸੈੱਟ ਕੀਤਾ ਜਾਵੇ, ਤਾਂ ਹੇਠਾਂ ਦਿੱਤੇ ਸਾਰੇ patterns ਇੱਕੋ ਜਿਹੇ ਹਨ (ਅਤੇ ਸਾਰੇ ``y`` attribute ਨੂੰ ``var`` variable ਨਾਲ bind ਕਰਦੇ ਹਨ)::"

msgid "Point(1, var)\n"

msgstr "Point(1, var)\n"

msgid "A recommended way to read patterns is to look at them as an extended form of what you would put on the left of an assignment, to understand which variables would be set to what. Only the standalone names (like ``var`` above) are assigned to by a match statement. Dotted names (like ``foo.bar``), attribute names (the ``x=`` and ``y=`` above) or class names (recognized by the \"(...)\" next to them like ``Point`` above) are never assigned to."

msgstr "Patterns ਨੂੰ ਸਮਝਣ ਦਾ ਇੱਕ ਵਧੀਆ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਉਨ੍ਹਾਂ ਨੂੰ assignment ਦੇ ਖੱਬੇ ਪਾਸੇ ਲਿਖੀ ਜਾਣ ਵਾਲੀ ਚੀਜ਼ ਦੇ ਵਿਸਤਾਰ ਵਜੋਂ ਵੇਖਿਆ ਜਾਵੇ, ਤਾਂ ਜੋ ਇਹ ਸਮਝ ਆ ਸਕੇ ਕਿ ਕਿਹੜੇ variables ਨੂੰ ਕਿਹੜੇ ਮੁੱਲ ਮਿਲਣਗੇ। ਕੇਵਲ standalone names (ਜਿਵੇਂ ਉੱਪਰ ``var``) ਨੂੰ ਹੀ match statement ਰਾਹੀਂ ਮੁੱਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। Dotted names (ਜਿਵੇਂ ``foo.bar``), attribute names (ਉੱਪਰਲੇ ``x=`` ਅਤੇ ``y=``) ਜਾਂ class names (ਜਿਵੇਂ ``Point``) ਨੂੰ ਕਦੇ ਵੀ ਮੁੱਲ ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ।"

msgid "Patterns can be arbitrarily nested. For example, if we have a short list of Points, with ``__match_args__`` added, we could match it like this::"

msgstr "Patterns ਨੂੰ ਮਨਚਾਹੇ ਢੰਗ ਨਾਲ nested ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇ ਸਾਡੇ ਕੋਲ ``__match_args__`` ਵਾਲੀ Points ਦੀ ਇੱਕ ਛੋਟੀ ਸੂਚੀ ਹੋਵੇ, ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ match ਕਰ ਸਕਦੇ ਹਾਂ::"

msgid "class Point:\n"

msgstr "class Point:\n"

msgid "We can add an ``if`` clause to a pattern, known as a \"guard\". If the guard is false, ``match`` goes on to try the next case block. Note that value capture happens before the guard is evaluated::"

msgstr "ਅਸੀਂ ਕਿਸੇ pattern ਨਾਲ ``if`` clause ਜੋੜ ਸਕਦੇ ਹਾਂ, ਜਿਸਨੂੰ \"guard\" ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਜੇ guard false ਹੋਵੇ, ਤਾਂ ``match`` ਅਗਲੇ case block ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਧਿਆਨ ਦਿਓ ਕਿ value capture guard ਦੀ ਜਾਂਚ ਤੋਂ ਪਹਿਲਾਂ ਹੋ ਜਾਂਦੀ ਹੈ::"

msgid "match point:\n"

msgstr "match point:\n"

msgid "Several other key features of this statement:"

msgstr "ਇਸ statement ਦੀਆਂ ਕੁਝ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ:"

msgid "Like unpacking assignments, tuple and list patterns have exactly the same meaning and actually match arbitrary sequences. An important exception is that they don't match iterators or strings."

msgstr "Unpacking assignments ਦੀ ਤਰ੍ਹਾਂ, tuple ਅਤੇ list patterns ਦਾ ਅਰਥ ਵੀ ਇੱਕੋ ਜਿਹਾ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਹ ਮਨਚਾਹੀਆਂ sequences ਨਾਲ match ਕਰ ਸਕਦੇ ਹਨ। ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਅਪਵਾਦ ਇਹ ਹੈ ਕਿ ਇਹ iterators ਜਾਂ strings ਨਾਲ match ਨਹੀਂ ਕਰਦੇ।"

msgid "Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, *rest)`` work similar to unpacking assignments. The name after ``*`` may also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items without binding the remaining items."

msgstr "Sequence patterns extended unpacking ਦਾ ਸਮਰਥਨ ਕਰਦੇ ਹਨ: ``[x, y, *rest]`` ਅਤੇ ``(x, y, *rest)`` unpacking assignments ਵਾਂਗ ਕੰਮ ਕਰਦੇ ਹਨ। ``*`` ਤੋਂ ਬਾਅਦ ਆਉਣ ਵਾਲਾ ਨਾਮ ``_`` ਵੀ ਹੋ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ``(x, y, *_)`` ਘੱਟੋ-ਘੱਟ ਦੋ items ਵਾਲੀ sequence ਨਾਲ match ਕਰਦਾ ਹੈ ਬਿਨਾਂ ਬਾਕੀ items ਨੂੰ bind ਕੀਤੇ।"

msgid "Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the ``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary. Unlike sequence patterns, extra keys are ignored. An unpacking like ``**rest`` is also supported. (But ``**_`` would be redundant, so it is not allowed.)"

msgstr "Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` dictionary ਵਿੱਚੋਂ ``\"bandwidth\"`` ਅਤੇ ``\"latency\"`` ਦੇ ਮੁੱਲ capture ਕਰਦੇ ਹਨ। Sequence patterns ਦੇ ਉਲਟ, ਵਾਧੂ keys ਨੂੰ ਅਣਡਿੱਠਾ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ``**rest`` ਵਰਗੀ unpacking ਦਾ ਵੀ ਸਮਰਥਨ ਹੈ। (ਪਰ ``**_`` ਬੇਲੋੜਾ ਹੋਵੇਗਾ, ਇਸ ਲਈ ਇਸਦੀ ਆਗਿਆ ਨਹੀਂ ਹੈ।)"

msgid "Subpatterns may be captured using the ``as`` keyword::"

msgstr "Subpatterns ਨੂੰ ``as`` keyword ਦੀ ਵਰਤੋਂ ਨਾਲ capture ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ::"

msgid "case (Point(x1, y1), Point(x2, y2) as p2): ..."

msgstr "case (Point(x1, y1), Point(x2, y2) as p2): ..."

msgid "will capture the second element of the input as ``p2`` (as long as the input is a sequence of two points)"

msgstr "ਇਹ input ਦੇ ਦੂਜੇ element ਨੂੰ ``p2`` ਵਜੋਂ capture ਕਰੇਗਾ (ਜਦੋਂ ਤੱਕ input ਦੋ points ਵਾਲੀ sequence ਹੈ)।"

msgid "Most literals are compared by equality, however the singletons ``True``, ``False`` and ``None`` are compared by identity."

msgstr "ਜ਼ਿਆਦਾਤਰ literals ਦੀ ਤੁਲਨਾ equality ਦੇ ਆਧਾਰ 'ਤੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ singletons ``True``, ``False`` ਅਤੇ ``None`` ਦੀ ਤੁਲਨਾ identity ਦੇ ਆਧਾਰ 'ਤੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।"

msgid "Patterns may use named constants. These must be dotted names to prevent them from being interpreted as capture variables::"

msgstr "Patterns named constants ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ। ਇਹ dotted names ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ ਤਾਂ ਜੋ ਇਨ੍ਹਾਂ ਨੂੰ capture variables ਵਜੋਂ ਨਾ ਸਮਝਿਆ ਜਾਵੇ::"

msgid "from enum import Enum\n"

msgstr "from enum import Enum\n"

msgid "For a more detailed explanation and additional examples, you can look into :pep:`636` which is written in a tutorial format."

msgstr "ਹੋਰ ਵਿਸਤ੍ਰਿਤ ਵਿਆਖਿਆ ਅਤੇ ਵਾਧੂ ਉਦਾਹਰਨਾਂ ਲਈ ਤੁਸੀਂ :pep:`636` ਵੇਖ ਸਕਦੇ ਹੋ, ਜੋ tutorial ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ।"

msgid "Defining Functions"

msgstr "Functions ਦੀ ਪਰਿਭਾਸ਼ਾ"

msgid "We can create a function that writes the Fibonacci series to an arbitrary boundary::"

msgstr "ਅਸੀਂ ਇੱਕ function ਬਣਾ ਸਕਦੇ ਹਾਂ ਜੋ Fibonacci series ਨੂੰ ਕਿਸੇ ਮਨਚਾਹੀ ਸੀਮਾ ਤੱਕ ਲਿਖੇ::"

msgid ">>> def fib(n): # write Fibonacci series less than n\n"

msgstr ">>> def fib(n): # write Fibonacci series less than n\n"

msgid "The keyword :keyword:`def` introduces a function *definition*. It must be followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line, and must be indented."

msgstr ":keyword:`def` keyword ਇੱਕ function *definition* ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ function ਦਾ ਨਾਮ ਅਤੇ formal parameters ਦੀ parenthesized list ਆਉਣੀ ਚਾਹੀਦੀ ਹੈ। Function ਦਾ body ਬਣਾਉਣ ਵਾਲੀਆਂ statements ਅਗਲੀ ਲਾਈਨ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਉਹਨਾਂ ਦਾ indented ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ।"

msgid "The first statement of the function body can optionally be a string literal; this string literal is the function's documentation string, or :dfn:`docstring`. (More about docstrings can be found in the section :ref:`tut-docstrings`.) There are tools which use docstrings to automatically produce online or printed documentation, or to let the user interactively browse through code; it's good practice to include docstrings in code that you write, so make a habit of it."

msgstr "Function body ਦੀ ਪਹਿਲੀ statement ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ ਇੱਕ string literal ਹੋ ਸਕਦੀ ਹੈ; ਇਸ string literal ਨੂੰ function ਦੀ documentation string ਜਾਂ :dfn:`docstring` ਕਿਹਾ ਜਾਂਦਾ ਹੈ। (:ref:`tut-docstrings` ਵਿੱਚ docstrings ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਮਿਲੇਗੀ।) ਕਈ tools docstrings ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਆਪ online ਜਾਂ printed documentation ਤਿਆਰ ਕਰਦੇ ਹਨ ਜਾਂ ਵਰਤੋਂਕਾਰ ਨੂੰ code ਨੂੰ interactively ਵੇਖਣ ਦੀ ਸੁਵਿਧਾ ਦਿੰਦੇ ਹਨ। ਇਸ ਲਈ ਆਪਣੇ code ਵਿੱਚ docstrings ਸ਼ਾਮਲ ਕਰਨਾ ਇੱਕ ਵਧੀਆ ਅਭਿਆਸ ਹੈ।"

msgid "The *execution* of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table; whereas variable references first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global symbol table, and finally in the table of built-in names. Thus, global variables and variables of enclosing functions cannot be directly assigned a value within a function (unless, for global variables, named in a :keyword:`global` statement, or, for variables of enclosing functions, named in a :keyword:`nonlocal` statement), although they may be referenced."

msgstr "ਕਿਸੇ function ਦੀ *execution* ਉਸਦੇ local variables ਲਈ ਇੱਕ ਨਵੀਂ symbol table ਬਣਾਉਂਦੀ ਹੈ। ਹੋਰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ, function ਦੇ ਅੰਦਰ ਕੀਤੀਆਂ ਸਾਰੀਆਂ variable assignments local symbol table ਵਿੱਚ ਸੰਭਾਲੀਆਂ ਜਾਂਦੀਆਂ ਹਨ; ਜਦਕਿ variable references ਪਹਿਲਾਂ local symbol table, ਫਿਰ enclosing functions ਦੀਆਂ local symbol tables, ਫਿਰ global symbol table ਅਤੇ ਆਖ਼ਰ ਵਿੱਚ built-in names ਦੀ table ਵਿੱਚ ਖੋਜੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਇਸ ਲਈ global variables ਅਤੇ enclosing functions ਦੇ variables ਨੂੰ function ਦੇ ਅੰਦਰ ਸਿੱਧਾ ਮੁੱਲ ਨਹੀਂ ਦਿੱਤਾ ਜਾ ਸਕਦਾ (ਸਿਵਾਏ ਉਹਨਾਂ ਦੇ ਜੋ :keyword:`global` ਜਾਂ :keyword:`nonlocal` statement ਰਾਹੀਂ ਘੋਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹੋਣ), ਹਾਲਾਂਕਿ ਉਨ੍ਹਾਂ ਨੂੰ reference ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।"

msgid "The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using *call by value* (where the *value* is always an object *reference*, not the value of the object). [#]_ When a function calls another function, or calls itself recursively, a new local symbol table is created for that call."

msgstr "ਜਦੋਂ ਕਿਸੇ function ਨੂੰ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਉਸਦੇ actual parameters (arguments) ਉਸ function ਦੀ local symbol table ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ; ਇਸ ਤਰ੍ਹਾਂ arguments *call by value* ਰਾਹੀਂ ਪਾਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ (ਜਿੱਥੇ *value* ਅਸਲ ਵਿੱਚ object ਦਾ *reference* ਹੁੰਦਾ ਹੈ, object ਦਾ ਮੁੱਲ ਨਹੀਂ)। [#]_ ਜਦੋਂ ਕੋਈ function ਕਿਸੇ ਹੋਰ function ਨੂੰ ਜਾਂ ਆਪਣੇ ਆਪ ਨੂੰ recursively ਕਾਲ ਕਰਦਾ ਹੈ, ਤਾਂ ਉਸ ਕਾਲ ਲਈ ਇੱਕ ਨਵੀਂ local symbol table ਬਣਾਈ ਜਾਂਦੀ ਹੈ।"

msgid "A function definition associates the function name with the function object in the current symbol table. The interpreter recognizes the object pointed to by that name as a user-defined function. Other names can also point to that same function object and can also be used to access the function::"

msgstr "Function definition ਮੌਜੂਦਾ symbol table ਵਿੱਚ function name ਨੂੰ function object ਨਾਲ ਜੋੜਦੀ ਹੈ। Interpreter ਉਸ ਨਾਮ ਦੁਆਰਾ ਦਰਸਾਏ object ਨੂੰ user-defined function ਵਜੋਂ ਪਛਾਣਦਾ ਹੈ। ਹੋਰ ਨਾਮ ਵੀ ਉਸੇ function object ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ function ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ::"

msgid ">>> fib\n"

msgstr ">>> fib\n"

msgid "Coming from other languages, you might object that ``fib`` is not a function but a procedure since it doesn't return a value. In fact, even functions without a :keyword:`return` statement do return a value, albeit a rather boring one. This value is called ``None`` (it's a built-in name). Writing the value ``None`` is normally suppressed by the interpreter if it would be the only value written. You can see it if you really want to using :func:`print`::"

msgstr "ਜੇ ਤੁਸੀਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਆ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਕਹਿ ਸਕਦੇ ਹੋ ਕਿ ``fib`` ਇੱਕ function ਨਹੀਂ ਸਗੋਂ ਇੱਕ procedure ਹੈ ਕਿਉਂਕਿ ਇਹ ਕੋਈ ਮੁੱਲ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ। ਅਸਲ ਵਿੱਚ, ਉਹ functions ਵੀ ਜਿਨ੍ਹਾਂ ਵਿੱਚ :keyword:`return` statement ਨਹੀਂ ਹੁੰਦੀ, ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਭਾਵੇਂ ਉਹ ਕਾਫ਼ੀ ਸਧਾਰਣ ਹੋਵੇ। ਇਸ ਮੁੱਲ ਨੂੰ ``None`` ਕਿਹਾ ਜਾਂਦਾ ਹੈ (ਇਹ ਇੱਕ built-in ਨਾਮ ਹੈ)। ਜੇ ``None`` ਹੀ ਇਕੱਲਾ ਲਿਖਿਆ ਜਾਣ ਵਾਲਾ ਮੁੱਲ ਹੋਵੇ, ਤਾਂ interpreter ਆਮ ਤੌਰ 'ਤੇ ਇਸਨੂੰ ਨਹੀਂ ਦਿਖਾਉਂਦਾ। ਜੇ ਤੁਸੀਂ ਇਸਨੂੰ ਦੇਖਣਾ ਚਾਹੋ ਤਾਂ :func:`print` ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ::"

msgid ">>> fib(0)\n"

msgstr ">>> fib(0)\n"

msgid "It is simple to write a function that returns a list of the numbers of the Fibonacci series, instead of printing it::"

msgstr "Fibonacci ਲੜੀ ਦੀਆਂ ਸੰਖਿਆਵਾਂ ਨੂੰ print ਕਰਨ ਦੀ ਬਜਾਏ ਉਹਨਾਂ ਦੀ ਇੱਕ list ਵਾਪਸ ਕਰਨ ਵਾਲਾ function ਲਿਖਣਾ ਆਸਾਨ ਹੈ::"

msgid ">>> def fib2(n): # return Fibonacci series up to n\n"

msgstr ">>> def fib2(n): # return Fibonacci series up to n\n"

msgid "This example, as usual, demonstrates some new Python features:"

msgstr "ਇਹ ਉਦਾਹਰਨ, ਹਮੇਸ਼ਾਂ ਦੀ ਤਰ੍ਹਾਂ, Python ਦੀਆਂ ਕੁਝ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ:"

msgid "The :keyword:`return` statement returns with a value from a function. :keyword:`!return` without an expression argument returns ``None``. Falling off the end of a function also returns ``None``."

msgstr ":keyword:`return` statement ਕਿਸੇ function ਤੋਂ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦੀ ਹੈ। expression argument ਤੋਂ ਬਿਨਾਂ :keyword:`!return` ``None`` ਵਾਪਸ ਕਰਦੀ ਹੈ। Function ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਜਾਣ 'ਤੇ ਵੀ ``None`` ਹੀ ਵਾਪਸ ਹੁੰਦਾ ਹੈ।"

msgid "The statement ``result.append(a)`` calls a *method* of the list object ``result``. A method is a function that 'belongs' to an object and is named ``obj.methodname``, where ``obj`` is some object (this may be an expression), and ``methodname`` is the name of a method that is defined by the object's type. Different types define different methods. Methods of different types may have the same name without causing ambiguity. (It is possible to define your own object types and methods, using *classes*, see :ref:`tut-classes`) The method :meth:`~list.append` shown in the example is defined for list objects; it adds a new element at the end of the list. In this example it is equivalent to ``result = result + [a]``, but more efficient."

msgstr "Statement ``result.append(a)`` list object ``result`` ਦੀ ਇੱਕ *method* ਨੂੰ ਕਾਲ ਕਰਦੀ ਹੈ। Method ਉਹ function ਹੁੰਦੀ ਹੈ ਜੋ ਕਿਸੇ object ਨਾਲ ਸੰਬੰਧਿਤ ਹੁੰਦੀ ਹੈ ਅਤੇ ਜਿਸਦਾ ਨਾਮ ``obj.methodname`` ਦੇ ਰੂਪ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਜਿੱਥੇ ``obj`` ਕੋਈ object ਹੁੰਦਾ ਹੈ (ਇਹ ਇੱਕ expression ਵੀ ਹੋ ਸਕਦਾ ਹੈ) ਅਤੇ ``methodname`` ਉਸ method ਦਾ ਨਾਮ ਹੁੰਦਾ ਹੈ ਜੋ object ਦੀ type ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀ ਗਈ ਹੋਵੇ। ਵੱਖ-ਵੱਖ types ਵੱਖ-ਵੱਖ methods ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀਆਂ ਹਨ। ਵੱਖਰੀਆਂ types ਦੀਆਂ methods ਦਾ ਨਾਮ ਇੱਕੋ ਜਿਹਾ ਹੋ ਸਕਦਾ ਹੈ ਬਿਨਾਂ ਕਿਸੇ ਗਲਤਫਹਮੀ ਦੇ। (*classes* ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੀਆਂ object types ਅਤੇ methods ਵੀ ਬਣਾਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ; ਵੇਖੋ :ref:`tut-classes`)। ਉਦਾਹਰਨ ਵਿੱਚ ਦਿਖਾਈ ਗਈ :meth:`~list.append` method list objects ਲਈ ਪਰਿਭਾਸ਼ਿਤ ਹੈ; ਇਹ list ਦੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਨਵਾਂ element ਜੋੜਦੀ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਇਹ ``result = result + [a]`` ਦੇ ਬਰਾਬਰ ਹੈ, ਪਰ ਹੋਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ।"

msgid "More on Defining Functions"

msgstr "ਫੰਕਸ਼ਨਾਂ ਦੀ ਪਰਿਭਾਸ਼ਾ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ"

msgid "It is also possible to define functions with a variable number of arguments. There are three forms, which can be combined."

msgstr "ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲਦੀ ਗਿਣਤੀ ਵਾਲੇ arguments ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ। ਇਸ ਦੀਆਂ ਤਿੰਨ ਰੂਪ-ਰੇਖਾਵਾਂ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਇਕੱਠੇ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।"

msgid "Default Argument Values"

msgstr "ਡਿਫਾਲਟ ਆਰਗਿਊਮੈਂਟ ਮੁੱਲ"

msgid "The most useful form is to specify a default value for one or more arguments. This creates a function that can be called with fewer arguments than it is defined to allow. For example::"

msgstr "ਸਭ ਤੋਂ ਲਾਭਦਾਇਕ ਤਰੀਕਾ ਇੱਕ ਜਾਂ ਵੱਧ arguments ਲਈ ਡਿਫਾਲਟ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ ਹੈ। ਇਸ ਨਾਲ ਅਜਿਹਾ function ਬਣਦਾ ਹੈ ਜਿਸਨੂੰ ਉਸਦੀ ਪਰਿਭਾਸ਼ਾ ਵਿੱਚ ਮਨਜ਼ੂਰ ਕੀਤੇ ਗਏ arguments ਤੋਂ ਘੱਟ arguments ਨਾਲ ਵੀ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ::"

msgid "def ask_ok(prompt, retries=4, reminder='Please try again!'):\n"

msgstr "def ask_ok(prompt, retries=4, reminder='Please try again!'):\n"

msgid "This function can be called in several ways:"

msgstr "ਇਸ function ਨੂੰ ਕਈ ਤਰੀਕਿਆਂ ਨਾਲ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:"

msgid ""

msgstr ""

msgid ""

msgstr ""

msgid "or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')``"

msgstr "ਜਾਂ ਸਾਰੇ arguments ਦੇ ਕੇ: ``ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')``"

msgid "This example also introduces the :keyword:`in` keyword. This tests whether or not a sequence contains a certain value."

msgstr "ਇਹ ਉਦਾਹਰਨ :keyword:`in` keyword ਨਾਲ ਵੀ ਜਾਣੂ ਕਰਵਾਉਂਦੀ ਹੈ। ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕਿਸੇ sequence ਵਿੱਚ ਕੋਈ ਖਾਸ ਮੁੱਲ ਮੌਜੂਦ ਹੈ ਜਾਂ ਨਹੀਂ।"

msgid "The default values are evaluated at the point of function definition in the *defining* scope, so that ::"

msgstr "ਡਿਫਾਲਟ ਮੁੱਲਾਂ ਦਾ ਮੁਲਾਂਕਣ function ਦੀ ਪਰਿਭਾਸ਼ਾ ਦੇ ਸਮੇਂ, *defining* scope ਵਿੱਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ ::"

msgid "i = 5\n"

msgstr "i = 5\n"

msgid "will print ``5``."

msgstr "ਇਹ ``5`` ਪ੍ਰਿੰਟ ਕਰੇਗਾ।"

msgid "**Important warning:** The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls::"

msgstr "**ਮਹੱਤਵਪੂਰਨ ਚੇਤਾਵਨੀ:** ਡਿਫਾਲਟ ਮੁੱਲ ਦਾ ਮੁਲਾਂਕਣ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਡਿਫਾਲਟ ਇੱਕ mutable object ਹੋਵੇ, ਜਿਵੇਂ list, dictionary ਜਾਂ ਬਹੁਤੀਆਂ classes ਦੇ instances, ਤਾਂ ਇਹ ਗੱਲ ਮਹੱਤਵਪੂਰਨ ਬਣ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤਾ function ਆਪਣੀਆਂ ਅਗਲੀਆਂ ਕਾਲਾਂ ਵਿੱਚ ਪਾਸ ਕੀਤੇ arguments ਨੂੰ ਇਕੱਠਾ ਕਰਦਾ ਰਹਿੰਦਾ ਹੈ::"

msgid "def f(a, L=[]):\n"

msgstr "def f(a, L=[]):\n"

msgid "This will print ::"

msgstr "ਇਹ ਪ੍ਰਿੰਟ ਕਰੇਗਾ ::"

msgid "[1]\n"

msgstr "[1]\n"

msgid "If you don't want the default to be shared between subsequent calls, you can write the function like this instead::"

msgstr "ਜੇ ਤੁਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਕਿ ਡਿਫਾਲਟ ਮੁੱਲ ਅਗਲੀਆਂ ਕਾਲਾਂ ਵਿੱਚ ਸਾਂਝਾ ਹੋਵੇ, ਤਾਂ function ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖ ਸਕਦੇ ਹੋ::"

msgid "def f(a, L=None):\n"

msgstr "def f(a, L=None):\n"

msgid "Keyword Arguments"

msgstr "ਕੀਵਰਡ ਆਰਗਿਊਮੈਂਟ"

msgid "Functions can also be called using :term:`keyword arguments <keyword argument>` of the form ``kwarg=value``. For instance, the following function::"

msgstr "Functions ਨੂੰ ``kwarg=value`` ਦੇ ਰੂਪ ਵਾਲੇ :term:`keyword arguments <keyword argument>` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੀ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤਾ function::"

msgid "def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n"

msgstr "def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n"

msgid "accepts one required argument (``voltage``) and three optional arguments (``state``, ``action``, and ``type``). This function can be called in any of the following ways::"

msgstr "ਇਹ ਇੱਕ ਲਾਜ਼ਮੀ argument (``voltage``) ਅਤੇ ਤਿੰਨ ਵਿਕਲਪਿਕ arguments (``state``, ``action`` ਅਤੇ ``type``) ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। ਇਸ function ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ::"

msgid "parrot(1000) # 1 positional argument\n"

msgstr "parrot(1000) # 1 positional argument\n"

msgid "but all the following calls would be invalid::"

msgstr "ਪਰ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਸਾਰੀਆਂ ਕਾਲਾਂ ਗਲਤ ਹੋਣਗੀਆਂ::"

msgid "parrot() # required argument missing\n"

msgstr "parrot() # required argument missing\n"

msgid "In a function call, keyword arguments must follow positional arguments. All the keyword arguments passed must match one of the arguments accepted by the function (e.g. ``actor`` is not a valid argument for the ``parrot`` function), and their order is not important. This also includes non-optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument may receive a value more than once. Here's an example that fails due to this restriction::"

msgstr "ਕਿਸੇ function call ਵਿੱਚ keyword arguments, positional arguments ਤੋਂ ਬਾਅਦ ਆਉਣੇ ਚਾਹੀਦੇ ਹਨ। ਪਾਸ ਕੀਤੇ ਗਏ ਸਾਰੇ keyword arguments function ਦੁਆਰਾ ਸਵੀਕਾਰ ਕੀਤੇ arguments ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਨਾਲ ਮਿਲਣੇ ਚਾਹੀਦੇ ਹਨ (ਉਦਾਹਰਨ ਵਜੋਂ ``actor`` , ``parrot`` function ਲਈ ਵੈਧ argument ਨਹੀਂ ਹੈ), ਅਤੇ ਉਨ੍ਹਾਂ ਦਾ ਕ੍ਰਮ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੁੰਦਾ। ਇਹ ਨਿਯਮ non-optional arguments ਉੱਤੇ ਵੀ ਲਾਗੂ ਹੁੰਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ ``parrot(voltage=1000)`` ਵੀ ਵੈਧ ਹੈ)। ਕਿਸੇ argument ਨੂੰ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ ਮੁੱਲ ਨਹੀਂ ਦਿੱਤਾ ਜਾ ਸਕਦਾ। ਹੇਠਾਂ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਜੋ ਇਸ ਪਾਬੰਦੀ ਕਾਰਨ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ::"

msgid ">>> def function(a):\n"