@@ -11,7 +11,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.15\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-07-07 16:22+0000\n"
+"POT-Creation-Date: 2026-07-19 14:48+0000\n"
 "PO-Revision-Date: 2025-09-16 00:02+0000\n"
 "Last-Translator: Bhuvansh Kataria, 2026\n"
 "Language-Team: Panjabi (Punjabi) (https://app.transifex.com/python-doc/"
@@ -89,9 +89,9 @@ msgid ""
 "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` ਵੇਖੋ।"
+"ਜੇ ਤੁਸੀਂ ਇੱਕੋ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਕਈ constants ਨਾਲ ਕਰ ਰਹੇ ਹੋ ਜਾਂ ਖਾਸ ਕਿਸਮਾਂ ਜਾਂ attributes ਦੀ "
+"ਜਾਂਚ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ :keyword:`!match` statement ਵੀ ਤੁਹਾਡੇ ਲਈ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ। ਹੋਰ "
+"ਜਾਣਕਾਰੀ ਲਈ :ref:`tut-match` ਵੇਖੋ।"
 
 msgid ":keyword:`!for` Statements"
 msgstr ":keyword:`!for` ਸਟੇਟਮੈਂਟਾਂ"
@@ -105,12 +105,11 @@ msgid ""
 "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 "
-"ਵਿੱਚ ਮੌਜੂਦ ਹੁੰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ:"
+"Python ਵਿੱਚ ` :keyword:`for` ` ਬਿਆਨ C ਜਾਂ Pascal ਵਿੱਚ ਤੁਸੀਂ ਜੋ ਵਰਤਦੇ ਹੋ, ਉਸ ਤੋਂ ਥੋੜ੍ਹਾ "
+"ਵੱਖਰਾ ਹੈ।  ਸਦਾ ਗਿਣਤੀਆਂ ਦੀ ਗਣਿਤਕ ਕ੍ਰਮਵਾਰ (ਜਿਵੇਂ ਪਾਸਕਲ ਵਿੱਚ) 'ਤੇ ਦੁਹਰਾਉਣ ਦੀ ਬਜਾਏ, ਜਾਂ "
+"ਉਪਭੋਗਤਾ ਨੂੰ ਦੁਹਰਾਉਣ ਕਦਮ ਅਤੇ ਰੋਕਣ ਦੀ ਸ਼ਰਤ ਦੋਹਾਂ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਜ਼ਾਦੀ ਦੇਣ ਦੀ ਬਜਾਏ (ਜਿਵੇਂ C "
+"ਵਿੱਚ), Python ਦਾ :keyword:`!for` ਬਿਆਨ ਕਿਸੇ ਵੀ ਕ੍ਰਮ (ਸੂਚੀ ਜਾਂ ਸਤਰ) ਦੀਆਂ ਆਈਟਮਾਂ 'ਤੇ, "
+"ਉਹਨਾਂ ਦੇ ਕ੍ਰਮ ਵਿੱਚ, ਦੁਹਰਾਉਂਦਾ ਹੈ।  ਉਦਾਹਰਨ ਵਜੋਂ (ਇਹ ਕੋਈ ਸ਼ਬਦ-ਚਿੱਤਰ ਨਹੀਂ ਹੈ):"
 
 msgid ""
 ">>> # Measure some strings:\n"
@@ -176,9 +175,8 @@ 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 ਤਿਆਰ ਕਰਦਾ "
-"ਹੈ::"
+"ਜੇ ਤੁਹਾਨੂੰ ਸੰਖਿਆਵਾਂ ਦੀ ਕਿਸੇ ਲੜੀ ਉੱਤੇ iterate ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇ, ਤਾਂ built-in function :func:"
+"`range` ਬਹੁਤ ਕੰਮ ਆਉਂਦਾ ਹੈ। ਇਹ arithmetic progressions ਤਿਆਰ ਕਰਦਾ ਹੈ::"
 
 msgid ""
 ">>> for i in range(5):\n"
@@ -205,10 +203,10 @@ msgid ""
 "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' ਕਿਹਾ ਜਾਂਦਾ ਹੈ)::"
+"ਦਿੱਤਾ ਗਿਆ ਅੰਤ ਬਿੰਦੂ ਕਦੇ ਵੀ ਤਿਆਰ ਕੀਤੀ ਗਈ ਕ੍ਰਮ ਦਾ ਹਿੱਸਾ ਨਹੀਂ ਹੁੰਦਾ; ``range(10)`` 10 ਮੁੱਲ "
+"ਤਿਆਰ ਕਰਦਾ ਹੈ, ਜੋ 10 ਲੰਬਾਈ ਵਾਲੀ ਕ੍ਰਮ ਦੀਆਂ ਆਈਟਮਾਂ ਲਈ ਵੈਧ ਸੂਚਕਾਂ ਹਨ। ਇਹ ਸੰਭਵ ਹੈ ਕਿ ਰੇਂਜ ਕਿਸੇ "
+"ਹੋਰ ਅੰਕ ਤੋਂ ਸ਼ੁਰੂ ਹੋਵੇ, ਜਾਂ ਵੱਖਰਾ ਵਾਧਾ (ਨਕਾਰਾਤਮਕ ਵੀ; ਕਈ ਵਾਰ ਇਸਨੂੰ 'ਸਟੈਪ' ਕਿਹਾ ਜਾਂਦਾ ਹੈ) "
+"ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਵੇ:"
 
 msgid ""
 ">>> list(range(5, 10))\n"
@@ -424,8 +422,8 @@ msgid ""
 "This is exemplified in the following :keyword:`!for` loop, which searches "
 "for prime numbers::"
 msgstr ""
-"ਇਸਦੀ ਉਦਾਹਰਨ ਹੇਠਾਂ ਦਿੱਤੇ :keyword:`!for` ਲੂਪ ਵਿੱਚ ਵੇਖੀ ਜਾ ਸਕਦੀ ਹੈ, ਜੋ ਅਭਾਜ ਸੰਖਿਆਵਾਂ "
-"(prime numbers) ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ::"
+"ਇਸਦੀ ਉਦਾਹਰਨ ਹੇਠਾਂ ਦਿੱਤੇ :keyword:`!for` ਲੂਪ ਵਿੱਚ ਵੇਖੀ ਜਾ ਸਕਦੀ ਹੈ, ਜੋ ਅਭਾਜ ਸੰਖਿਆਵਾਂ ਦੀ "
+"ਖੋਜ ਕਰਦਾ ਹੈ::"
 
 msgid ""
 ">>> for n in range(2, 10):\n"
@@ -478,10 +476,10 @@ msgid ""
 "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 ਚੱਲੇਗਾ।"
+"else ਕਲੌਜ਼ ਨੂੰ ਸੋਚਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਇਸਨੂੰ ਲੂਪ ਦੇ ਅੰਦਰ ``if`` ਨਾਲ ਜੋੜਿਆ ਹੋਇਆ ਸਮਝੋ। ਜਦੋਂ "
+"ਲੂਪ ਚਲਦਾ ਹੈ, ਇਹ if/if/if/else ਵਰਗੀ ਕ੍ਰਮਵਾਰ ਚਲਾਏਗਾ। loop ਦੇ ਅੰਦਰ ``if`` ਕਈ ਵਾਰੀ "
+"ਆਉਂਦਾ ਹੈ। ਜੇ ਇਹ ਸ਼ਰਤ ਕਦੇ ਵੀ ਸੱਚੀ ਹੋਵੇ, ਤਾਂ ``break`` ਚਲਦਾ ਹੈ। ਜੇ ਇਹ ਸ਼ਰਤ ਕਦੇ ਵੀ ਸੱਚੀ ਨਾ "
+"ਹੋਵੇ, ਤਾਂ loop ਦੇ ਬਾਹਰਲਾ ``else`` ਕਲੌਜ਼ ਚਲਦਾ ਹੈ।"
 
 msgid ""
 "When used with a loop, the ``else`` clause has more in common with the "
@@ -491,11 +489,11 @@ msgid ""
 "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` ਵੇਖੋ।"
+"ਜਦੋਂ ਲੂਪ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ :keyword:`try` statement ਦੇ ``else`` clause ਨਾਲ "
+"ਵੱਧ ਮਿਲਦਾ ਹੈ, ਨਾ ਕਿ ``if`` statement ਦੇ ``else`` ਨਾਲ। ``try`` statement ਦਾ "
+"``else`` ਉਸ ਵੇਲੇ ਚੱਲਦਾ ਹੈ ਜਦੋਂ ਕੋਈ exception ਨਹੀਂ ਆਉਂਦੀ, ਅਤੇ ਲੂਪ ਦਾ ``else`` ਉਸ ਵੇਲੇ ਚੱਲਦਾ "
+"ਹੈ ਜਦੋਂ ਕੋਈ ``break`` ਨਹੀਂ ਹੁੰਦਾ। ``try`` statement ਅਤੇ exceptions ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ "
+"ਲਈ :ref:`tut-handling` ਵੇਖੋ।"
 
 msgid ":keyword:`!pass` Statements"
 msgstr ":keyword:`!pass` Statements"
@@ -518,7 +516,7 @@ msgstr ""
 "..."
 
 msgid "This is commonly used for creating minimal classes::"
-msgstr "ਇਸਦੀ ਵਰਤੋਂ ਆਮ ਤੌਰ 'ਤੇ ਘੱਟੋ-ਘੱਟ (minimal) classes ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ::"
+msgstr "ਇਸਦੀ ਵਰਤੋਂ ਆਮ ਤੌਰ 'ਤੇ ਘੱਟੋ-ਘੱਟ classes ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ::"
 
 msgid ""
 ">>> class MyEmptyClass:\n"
@@ -536,8 +534,8 @@ msgid ""
 "ignored::"
 msgstr ""
 ":keyword:`pass` ਦੀ ਇੱਕ ਹੋਰ ਵਰਤੋਂ function ਜਾਂ conditional body ਲਈ placeholder ਵਜੋਂ "
-"ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਨਵਾਂ code ਲਿਖ ਰਹੇ ਹੋ। ਇਹ ਤੁਹਾਨੂੰ ਹੋਰ ਅਮੂਰਤ (abstract) ਪੱਧਰ 'ਤੇ ਸੋਚਦੇ ਰਹਿਣ ਦੀ "
-"ਆਗਿਆ ਦਿੰਦਾ ਹੈ। :keyword:`!pass` ਨੂੰ ਚੁੱਪਚਾਪ ਅਣਡਿੱਠਾ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ::"
+"ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਨਵਾਂ code ਲਿਖ ਰਹੇ ਹੋ। ਇਹ ਤੁਹਾਨੂੰ ਹੋਰ ਅਮੂਰਤ ਪੱਧਰ 'ਤੇ ਸੋਚਦੇ ਰਹਿਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। :"
+"keyword:`!pass` ਨੂੰ ਚੁੱਪਚਾਪ ਅਣਡਿੱਠਾ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ::"
 
 msgid ""
 ">>> def initlog(*args):\n"
@@ -572,13 +570,12 @@ msgid ""
 "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 ਨਹੀਂ "
-"ਚਲਦੀ।"
+":keyword:`match` ਬਿਆਨ ਇੱਕ ਐਕਸਪ੍ਰੈਸ਼ਨ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸਦੀ ਕੀਮਤ ਨੂੰ ਇੱਕ ਜਾਂ ਵੱਧ ਕੇਸ ਬਲਾਕਾਂ ਵਿੱਚ "
+"ਦਿੱਤੇ ਗਏ ਲਗਾਤਾਰ ਪੈਟਰਨਾਂ ਨਾਲ ਤੁਲਨਾ ਕਰਦਾ ਹੈ। ਇਹ ਸਤਹੀ ਤੌਰ 'ਤੇ C, Java ਜਾਂ JavaScript (ਅਤੇ "
+"ਹੋਰ ਕਈ ਭਾਸ਼ਾਵਾਂ) ਵਿੱਚ switch ਬਿਆਨ ਵਰਗਾ ਲੱਗਦਾ ਹੈ, ਪਰ ਇਹ Rust ਜਾਂ Haskell ਵਰਗੀਆਂ "
+"ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ pattern matching ਨਾਲ ਵੱਧ ਮਿਲਦਾ-ਜੁਲਦਾ ਹੈ। ਸਿਰਫ਼ ਉਹ ਪਹਿਲਾ ਪੈਟਰਨ ਜੋ ਮੇਲ "
+"ਖਾਂਦਾ ਹੈ, ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹ ਮੁੱਲ ਤੋਂ ਤੱਤ (ਕ੍ਰਮ ਦੇ ਐਲੀਮੈਂਟ ਜਾਂ ਆਬਜੈਕਟ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ) "
+"ਵੈਰੀਏਬਲਾਂ ਵਿੱਚ ਕੱਢ ਸਕਦਾ ਹੈ। ਜੇ ਕੋਈ ਕੇਸ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਤਾਂ ਕੋਈ ਵੀ ਸ਼ਾਖਾ ਚਲਾਈ ਨਹੀਂ ਜਾਂਦੀ।"
 
 msgid ""
 "The simplest form compares a subject value against one or more literals::"
@@ -754,11 +751,12 @@ msgid ""
 "(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``) ਨੂੰ ਕਦੇ ਵੀ ਮੁੱਲ ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ।"
+"ਪੈਟਰਨਾਂ ਨੂੰ ਪੜ੍ਹਨ ਦਾ ਇੱਕ ਸਿਫ਼ਾਰਸ਼ੀ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਉਨ੍ਹਾਂ ਨੂੰ ਉਸ ਚੀਜ਼ ਦੇ ਵਿਸਤ੍ਰਿਤ ਰੂਪ ਵਜੋਂ ਦੇਖਿਆ "
+"ਜਾਵੇ ਜੋ ਤੁਸੀਂ ਕਿਸੇ ਅਸਾਈਨਮੈਂਟ ਦੇ ਖੱਬੇ ਪਾਸੇ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਜੋ ਇਹ ਸਮਝਿਆ ਜਾ ਸਕੇ ਕਿ ਕਿਹੜੇ ਵੇਰੀਏਬਲ ਕਿਸ "
+"ਮੁੱਲ ਨਾਲ ਸੈੱਟ ਕੀਤੇ ਜਾਣਗੇ। ਸਿਰਫ਼ ਸਟੈਂਡਅਲੋਨ ਨਾਮ (ਜਿਵੇਂ ਉਪਰ ਦਿੱਤਾ ``var`` ) ਮੈਚ ਸਟੇਟਮੈਂਟ ਦੁਆਰਾ "
+"ਅਸਾਈਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਡੌਟਡ ਨਾਮ (ਜਿਵੇਂ ``foo.bar``), ਐਟ੍ਰਿਬਿਊਟ ਨਾਮ (ਉਪਰ ਦਿੱਤੇ ``x=`` ਅਤੇ "
+"``y=`` ) ਜਾਂ ਕਲਾਸ ਨਾਮ (ਜਿਨ੍ਹਾਂ ਦੇ ਨਾਲ \"(...)\" ਲਿਖਿਆ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਉਪਰ ਦਿੱਤਾ "
+"``Point`` ) ਕਦੇ ਵੀ ਅਸਾਈਨ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ।"
 
 msgid ""
 "Patterns can be arbitrarily nested.  For example, if we have a short list of "
@@ -1736,8 +1734,8 @@ msgid ""
 "between the positional argument ``name``  and ``**kwds`` which has ``name`` "
 "as a key::"
 msgstr ""
-"ਅੰਤ ਵਿੱਚ, ਇਸ function definition ਨੂੰ ਵੇਖੋ ਜਿਸ ਵਿੱਚ positional argument ``name`` ਅਤੇ "
-"``**kwds`` (ਜਿਸ ਵਿੱਚ ``name`` ਇੱਕ key ਵਜੋਂ ਹੈ) ਦੇ ਵਿਚਕਾਰ ਟਕਰਾਅ ਦੀ ਸੰਭਾਵਨਾ ਹੈ::"
+"ਅੰਤ ਵਿੱਚ, ਇਸ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਵੇਖੋ ਜਿਸ ਵਿੱਚ ਸਥਾਨ-ਅਧਾਰਿਤ ਦਲੀਲ ``name`` ਅਤੇ "
+"``**kwds``, ਜਿਸ ਵਿੱਚ ``name`` ਇੱਕ ਕੁੰਜੀ ਹੈ, ਵਿਚਕਾਰ ਸੰਭਾਵੀ ਟਕਰਾਅ ਹੈ::"
 
 msgid ""
 "def foo(name, **kwds):\n"
@@ -1802,8 +1800,8 @@ msgid ""
 "The use case will determine which parameters to use in the function "
 "definition::"
 msgstr ""
-"ਵਰਤੋਂ ਦੀ ਲੋੜ (use case) ਇਹ ਨਿਰਧਾਰਤ ਕਰੇਗੀ ਕਿ function definition ਵਿੱਚ ਕਿਹੜੇ "
-"parameters ਵਰਤਣੇ ਹਨ::"
+"ਵਰਤੋਂ ਦੀ ਲੋੜ ਇਹ ਨਿਰਧਾਰਤ ਕਰੇਗੀ ਕਿ function definition ਵਿੱਚ ਕਿਹੜੇ parameters ਵਰਤਣੇ "
+"ਹਨ::"
 
 msgid "def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):"
 msgstr "def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):"
@@ -1837,7 +1835,7 @@ msgid ""
 "parameter's name is modified in the future."
 msgstr ""
 "ਕਿਸੇ API ਲਈ positional-only parameters ਵਰਤੋ ਤਾਂ ਜੋ ਭਵਿੱਖ ਵਿੱਚ parameter ਦਾ ਨਾਮ "
-"ਬਦਲਣ ਨਾਲ API ਦੀ ਅਨੁਕੂਲਤਾ (compatibility) ਨਾ ਟੁੱਟੇ।"
+"ਬਦਲਣ ਨਾਲ API ਦੀ ਅਨੁਕੂਲਤਾ ਨਾ ਟੁੱਟੇ।"
 
 msgid "Arbitrary Argument Lists"
 msgstr "ਮਨਮਾਨੀਆਂ ਆਰਗਿਊਮੈਂਟ ਸੂਚੀਆਂ"