introduction.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Bhuvansh Kataria, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-08-15 14:15+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/"
"teams/5390/pa/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pa\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\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"
"spam = 1  # and this is the second comment\n"
"          # ... and now a third!\n"
"text = \"# This is not a comment because it's inside quotes.\""
msgstr ""
"# this is the first comment\n"
"spam = 1  # and this is the second comment\n"
"          # ... and now a third!\n"
"text = \"# This is not a comment because it's inside quotes.\""

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"
"4\n"
">>> 50 - 5*6\n"
"20\n"
">>> (50 - 5*6) / 4\n"
"5.0\n"
">>> 8 / 5  # division always returns a floating-point number\n"
"1.6"
msgstr ""
">>> 2 + 2\n"
"4\n"
">>> 50 - 5*6\n"
"20\n"
">>> (50 - 5*6) / 4\n"
"5.0\n"
">>> 8 / 5  # division always returns a floating-point number\n"
"1.6"

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 ਵਰਤ ਸਕਦੇ ਹੋ; ਬਾਕੀ ਕੱਢਣ ਲਈ ``%`` "
"ਵਰਤ ਸਕਦੇ ਹੋ::"

msgid ""
">>> 17 / 3  # classic division returns a float\n"
"5.666666666666667\n"
">>>\n"
">>> 17 // 3  # floor division discards the fractional part\n"
"5\n"
">>> 17 % 3  # the % operator returns the remainder of the division\n"
"2\n"
">>> 5 * 3 + 2  # floored quotient * divisor + remainder\n"
"17"
msgstr ""
">>> 17 / 3  # classic division returns a float\n"
"5.666666666666667\n"
">>>\n"
">>> 17 // 3  # floor division discards the fractional part\n"
"5\n"
">>> 17 % 3  # the % operator returns the remainder of the division\n"
"2\n"
">>> 5 * 3 + 2  # floored quotient * divisor + remainder\n"
"17"

msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr "ਪਾਇਥਨ ਵਿੱਚ ਘਾਤਾਂ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ``**`` operator ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ [#]_::"

msgid ""
">>> 5 ** 2  # 5 squared\n"
"25\n"
">>> 2 ** 7  # 2 to the power of 7\n"
"128"
msgstr ""
">>> 5 ** 2  # 5 squared\n"
"25\n"
">>> 2 ** 7  # 2 to the power of 7\n"
"128"

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"
">>> height = 5 * 9\n"
">>> width * height\n"
"900"
msgstr ""
">>> width = 20\n"
">>> height = 5 * 9\n"
">>> width * height\n"
"900"

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"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'n' is not defined"
msgstr ""
">>> n  # try to access an undefined variable\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'n' is not defined"

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"
"14.0"
msgstr ""
">>> 4 * 3.75 - 1\n"
"14.0"

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"
">>> price = 100.50\n"
">>> price * tax\n"
"12.5625\n"
">>> price + _\n"
"113.0625\n"
">>> round(_, 2)\n"
"113.06"
msgstr ""
">>> tax = 12.5 / 100\n"
">>> price = 100.50\n"
">>> price * tax\n"
"12.5625\n"
">>> price + _\n"
"113.0625\n"
">>> round(_, 2)\n"
"113.06"

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 ਨੂੰ ਵਰਤੋਂਕਾਰ ਵੱਲੋਂ ਕੇਵਲ ਪੜ੍ਹਨਯੋਗ ਸਮਝਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸਨੂੰ ਖੁਦ ਕੋਈ ਮੁੱਲ ਨਾ ਦਿਓ "
"--- ਨਹੀਂ ਤਾਂ ਇਸੇ ਨਾਮ ਵਾਲਾ ਇੱਕ ਸੁਤੰਤਰ 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 ਸਮਰਥਨ ਹੈ ਅਤੇ "
"ਕਲਪਨਾਤਮਕ ਭਾਗ ਦਰਸਾਉਣ ਲਈ ``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"
"'spam eggs'\n"
">>> \"Paris rabbit got your back :)! Yay!\"  # double quotes\n"
"'Paris rabbit got your back :)! Yay!'\n"
">>> '1975'  # digits and numerals enclosed in quotes are also strings\n"
"'1975'"
msgstr ""
">>> 'spam eggs'  # single quotes\n"
"'spam eggs'\n"
">>> \"Paris rabbit got your back :)! Yay!\"  # double quotes\n"
"'Paris rabbit got your back :)! Yay!'\n"
">>> '1975'  # digits and numerals enclosed in quotes are also strings\n"
"'1975'"

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"
"\"doesn't\"\n"
">>> \"doesn't\"  # ...or use double quotes instead\n"
"\"doesn't\"\n"
">>> '\"Yes,\" they said.'\n"
"'\"Yes,\" they said.'\n"
">>> \"\\\"Yes,\\\" they said.\"\n"
"'\"Yes,\" they said.'\n"
">>> '\"Isn\\'t,\" they said.'\n"
"'\"Isn\\'t,\" they said.'"
msgstr ""
">>> 'doesn\\'t'  # use \\' to escape the single quote...\n"
"\"doesn't\"\n"
">>> \"doesn't\"  # ...or use double quotes instead\n"
"\"doesn't\"\n"
">>> '\"Yes,\" they said.'\n"
"'\"Yes,\" they said.'\n"
">>> \"\\\"Yes,\\\" they said.\"\n"
"'\"Yes,\" they said.'\n"
">>> '\"Isn\\'t,\" they said.'\n"
"'\"Isn\\'t,\" they said.'"

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"
">>> s  # without print(), special characters are included in the string\n"
"'First line.\\nSecond line.'\n"
">>> print(s)  # with print(), special characters are interpreted, so \\n "
"produces new line\n"
"First line.\n"
"Second line."
msgstr ""
">>> s = 'First line.\\nSecond line.'  # \\n means newline\n"
">>> s  # without print(), special characters are included in the string\n"
"'First line.\\nSecond line.'\n"
">>> print(s)  # with print(), special characters are interpreted, so \\n "
"produces new line\n"
"First line.\n"
"Second line."

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"
"C:      his\n"
"ame\n"
">>> print(r'C:\\this\\name')  # note the r before the quote\n"
"C:\\this\\name"
msgstr ""
">>> print('C:\\this\\name')  # here \\t means tab, \\n means newline\n"
"C:      his\n"
"ame\n"
">>> print(r'C:\\this\\name')  # note the r before the quote\n"
"C:\\this\\name"

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 ``\\`` ਅੱਖਰਾਂ ਦੀ ਵਿਸਮ ਗਿਣਤੀ "
"ਨਾਲ ਸਮਾਪਤ ਨਹੀਂ ਹੋ ਸਕਦੀ। ਹੋਰ ਜਾਣਕਾਰੀ ਅਤੇ ਹੱਲਾਂ ਲਈ :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"
"... Usage: thingy [OPTIONS]\n"
"...      -h                        Display this usage message\n"
"...      -H hostname               Hostname to connect to\n"
"... \"\"\")\n"
"Usage: thingy [OPTIONS]\n"
"     -h                        Display this usage message\n"
"     -H hostname               Hostname to connect to\n"
"\n"
">>>"
msgstr ""
">>> print(\"\"\"\\\n"
"... Usage: thingy [OPTIONS]\n"
"...      -h                        Display this usage message\n"
"...      -H hostname               Hostname to connect to\n"
"... \"\"\")\n"
"Usage: thingy [OPTIONS]\n"
"     -h                        Display this usage message\n"
"     -H hostname               Hostname to connect to\n"
"\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"
">>> 3 * 'un' + 'ium'\n"
"'unununium'"
msgstr ""
">>> # 3 times 'un', followed by 'ium'\n"
">>> 3 * 'un' + 'ium'\n"
"'unununium'"

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"
"'Python'"
msgstr ""
">>> 'Py' 'thon'\n"
"'Python'"

msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr ""
"ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਉਸ ਵੇਲੇ ਲਾਭਦਾਇਕ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਲੰਬੀਆਂ strings ਨੂੰ ਕਈ ਲਾਈਨਾਂ ਵਿੱਚ "
"ਵੰਡਣਾ ਚਾਹੁੰਦੇ ਹੋ::"

msgid ""
">>> text = ('Put several strings within parentheses '\n"
"...         'to have them joined together.')\n"
">>> text\n"
"'Put several strings within parentheses to have them joined together.'"
msgstr ""
">>> text = ('Put several strings within parentheses '\n"
"...         'to have them joined together.')\n"
">>> text\n"
"'Put several strings within parentheses to have them joined together.'"

msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
"ਹਾਲਾਂਕਿ ਇਹ ਸਿਰਫ਼ literals ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, variables ਜਾਂ expressions ਨਾਲ ਨਹੀਂ::"

msgid ""
">>> prefix = 'Py'\n"
">>> prefix 'thon'  # can't concatenate a variable and a string literal\n"
"  File \"<stdin>\", line 1\n"
"    prefix 'thon'\n"
"           ^^^^^^\n"
"SyntaxError: invalid syntax\n"
">>> ('un' * 3) 'ium'\n"
"  File \"<stdin>\", line 1\n"
"    ('un' * 3) 'ium'\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"
msgstr ""
">>> prefix = 'Py'\n"
">>> prefix 'thon'  # can't concatenate a variable and a string literal\n"
"  File \"<stdin>\", line 1\n"
"    prefix 'thon'\n"
"           ^^^^^^\n"
"SyntaxError: invalid syntax\n"
">>> ('un' * 3) 'ium'\n"
"  File \"<stdin>\", line 1\n"
"    ('un' * 3) 'ium'\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"

msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr ""
"ਜੇ ਤੁਸੀਂ variables ਜਾਂ ਕਿਸੇ variable ਅਤੇ literal ਨੂੰ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ``+`` ਵਰਤੋ::"

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

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"
">>> word[0]  # character in position 0\n"
"'P'\n"
">>> word[5]  # character in position 5\n"
"'n'"
msgstr ""
">>> word = 'Python'\n"
">>> word[0]  # character in position 0\n"
"'P'\n"
">>> word[5]  # character in position 5\n"
"'n'"

msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr "ਸੱਜੇ ਪਾਸੇ ਤੋਂ ਗਿਣਤੀ ਸ਼ੁਰੂ ਕਰਨ ਲਈ indices ਨਕਾਰਾਤਮਕ ਵੀ ਹੋ ਸਕਦੇ ਹਨ::"

msgid ""
">>> word[-1]  # last character\n"
"'n'\n"
">>> word[-2]  # second-last character\n"
"'o'\n"
">>> word[-6]\n"
"'P'"
msgstr ""
">>> word[-1]  # last character\n"
"'n'\n"
">>> word[-2]  # second-last character\n"
"'o'\n"
">>> word[-6]\n"
"'P'"

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"
"'Py'\n"
">>> word[2:5]  # characters from position 2 (included) to 5 (excluded)\n"
"'tho'"
msgstr ""
">>> word[0:2]  # characters from position 0 (included) to 2 (excluded)\n"
"'Py'\n"
">>> word[2:5]  # characters from position 2 (included) to 5 (excluded)\n"
"'tho'"

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"
"'Py'\n"
">>> word[4:]   # characters from position 4 (included) to the end\n"
"'on'\n"
">>> word[-2:]  # characters from the second-last (included) to the end\n"
"'on'"
msgstr ""
">>> word[:2]   # character from the beginning to position 2 (excluded)\n"
"'Py'\n"
">>> word[4:]   # characters from position 4 (included) to the end\n"
"'on'\n"
">>> word[-2:]  # characters from the second-last (included) to the end\n"
"'on'"

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"
"'Python'\n"
">>> word[:4] + word[4:]\n"
"'Python'"
msgstr ""
">>> word[:2] + word[2:]\n"
"'Python'\n"
">>> word[:4] + word[4:]\n"
"'Python'"

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"
" | P | y | t | h | o | n |\n"
" +---+---+---+---+---+---+\n"
" 0   1   2   3   4   5   6\n"
"-6  -5  -4  -3  -2  -1"
msgstr ""
" +---+---+---+---+---+---+\n"
" | P | y | t | h | o | n |\n"
" +---+---+---+---+---+---+\n"
" 0   1   2   3   4   5   6\n"
"-6  -5  -4  -3  -2  -1"

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 ਵਰਤਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਨਾਲ ਗਲਤੀ ਆਵੇਗੀ::"

msgid ""
">>> word[42]  # the word only has 6 characters\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"IndexError: string index out of range"
msgstr ""
">>> word[42]  # the word only has 6 characters\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"IndexError: string index out of range"

msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
"ਹਾਲਾਂਕਿ slicing ਲਈ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਵਾਲੇ slice indices ਨੂੰ ਸੁਚੱਜੇ ਢੰਗ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ::"

msgid ""
">>> word[4:42]\n"
"'on'\n"
">>> word[42:]\n"
"''"
msgstr ""
">>> word[4:42]\n"
"'on'\n"
">>> word[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"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment\n"
">>> word[2:] = 'py'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment"
msgstr ""
">>> word[0] = 'J'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment\n"
">>> word[2:] = 'py'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment"

msgid "If you need a different string, you should create a new one::"
msgstr "ਜੇ ਤੁਹਾਨੂੰ ਵੱਖਰੀ string ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਨਵੀਂ string ਬਣਾਉਣੀ ਚਾਹੀਦੀ ਹੈ::"

msgid ""
">>> 'J' + word[1:]\n"
"'Jython'\n"
">>> word[:2] + 'py'\n"
"'Pypy'"
msgstr ""
">>> 'J' + word[1:]\n"
"'Jython'\n"
">>> word[:2] + 'py'\n"
"'Pypy'"

msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ :func:`len` ਸਟਰਿੰਗ ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਕਰਦਾ ਹੈ::"

msgid ""
">>> s = 'supercalifragilisticexpialidocious'\n"
">>> len(s)\n"
"34"
msgstr ""
">>> s = 'supercalifragilisticexpialidocious'\n"
">>> len(s)\n"
"34"

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"
">>> squares\n"
"[1, 4, 9, 16, 25]"
msgstr ""
">>> squares = [1, 4, 9, 16, 25]\n"
">>> squares\n"
"[1, 4, 9, 16, 25]"

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"
"1\n"
">>> squares[-1]\n"
"25\n"
">>> squares[-3:]  # slicing returns a new list\n"
"[9, 16, 25]"
msgstr ""
">>> squares[0]  # indexing returns the item\n"
"1\n"
">>> squares[-1]\n"
"25\n"
">>> squares[-3:]  # slicing returns a new list\n"
"[9, 16, 25]"

msgid "Lists also support operations like concatenation::"
msgstr "ਸੂਚੀਆਂ concatenation ਵਰਗੀਆਂ ਕਾਰਵਾਈਆਂ ਦਾ ਵੀ ਸਮਰਥਨ ਕਰਦੀਆਂ ਹਨ::"

msgid ""
">>> squares + [36, 49, 64, 81, 100]\n"
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
msgstr ""
">>> squares + [36, 49, 64, 81, 100]\n"
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"

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"
">>> 4 ** 3  # the cube of 4 is 64, not 65!\n"
"64\n"
">>> cubes[3] = 64  # replace the wrong value\n"
">>> cubes\n"
"[1, 8, 27, 64, 125]"
msgstr ""
">>> cubes = [1, 8, 27, 65, 125]  # something's wrong here\n"
">>> 4 ** 3  # the cube of 4 is 64, not 65!\n"
"64\n"
">>> cubes[3] = 64  # replace the wrong value\n"
">>> cubes\n"
"[1, 8, 27, 64, 125]"

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"
">>> cubes.append(7 ** 3)  # and the cube of 7\n"
">>> cubes\n"
"[1, 8, 27, 64, 125, 216, 343]"
msgstr ""
">>> cubes.append(216)  # add the cube of 6\n"
">>> cubes.append(7 ** 3)  # and the cube of 7\n"
">>> cubes\n"
"[1, 8, 27, 64, 125, 216, 343]"

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"
">>> rgba = rgb\n"
">>> id(rgb) == id(rgba)  # they reference the same object\n"
"True\n"
">>> rgba.append(\"Alph\")\n"
">>> rgb\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
msgstr ""
">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"
">>> rgba = rgb\n"
">>> id(rgb) == id(rgba)  # they reference the same object\n"
"True\n"
">>> rgba.append(\"Alph\")\n"
">>> rgb\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"

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"
">>> correct_rgba[-1] = \"Alpha\"\n"
">>> correct_rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n"
">>> rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
msgstr ""
">>> correct_rgba = rgba[:]\n"
">>> correct_rgba[-1] = \"Alpha\"\n"
">>> correct_rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n"
">>> rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"

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"
">>> letters\n"
"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> # replace some values\n"
">>> letters[2:5] = ['C', 'D', 'E']\n"
">>> letters\n"
"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
">>> # now remove them\n"
">>> letters[2:5] = []\n"
">>> letters\n"
"['a', 'b', 'f', 'g']\n"
">>> # clear the list by replacing all the elements with an empty list\n"
">>> letters[:] = []\n"
">>> letters\n"
"[]"
msgstr ""
">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> letters\n"
"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> # replace some values\n"
">>> letters[2:5] = ['C', 'D', 'E']\n"
">>> letters\n"
"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
">>> # now remove them\n"
">>> letters[2:5] = []\n"
">>> letters\n"
"['a', 'b', 'f', 'g']\n"
">>> # clear the list by replacing all the elements with an empty list\n"
">>> letters[:] = []\n"
">>> letters\n"
"[]"

msgid "The built-in function :func:`len` also applies to lists::"
msgstr "ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ :func:`len` ਸੂਚੀਆਂ ਉੱਤੇ ਵੀ ਲਾਗੂ ਹੁੰਦਾ ਹੈ::"

msgid ""
">>> letters = ['a', 'b', 'c', 'd']\n"
">>> len(letters)\n"
"4"
msgstr ""
">>> letters = ['a', 'b', 'c', 'd']\n"
">>> len(letters)\n"
"4"

msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
"ਸੂਚੀਆਂ ਨੂੰ nested ਬਣਾਉਣਾ (ਅਰਥਾਤ ਹੋਰ ਸੂਚੀਆਂ ਨੂੰ ਸਮੇਟਣ ਵਾਲੀਆਂ ਸੂਚੀਆਂ ਬਣਾਉਣਾ) ਸੰਭਵ ਹੈ, ਉਦਾਹਰਨ "
"ਲਈ::"

msgid ""
">>> a = ['a', 'b', 'c']\n"
">>> n = [1, 2, 3]\n"
">>> x = [a, n]\n"
">>> x\n"
"[['a', 'b', 'c'], [1, 2, 3]]\n"
">>> x[0]\n"
"['a', 'b', 'c']\n"
">>> x[0][1]\n"
"'b'"
msgstr ""
">>> a = ['a', 'b', 'c']\n"
">>> n = [1, 2, 3]\n"
">>> x = [a, n]\n"
">>> x\n"
"[['a', 'b', 'c'], [1, 2, 3]]\n"
">>> x[0]\n"
"['a', 'b', 'c']\n"
">>> x[0][1]\n"
"'b'"

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>`_ ਦਾ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਉਪ-ਕ੍ਰਮ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖ ਸਕਦੇ ਹਾਂ::"

msgid ""
">>> # Fibonacci series:\n"
">>> # the sum of two elements defines the next\n"
">>> a, b = 0, 1\n"
">>> while a < 10:\n"
"...     print(a)\n"
"...     a, b = b, a+b\n"
"...\n"
"0\n"
"1\n"
"1\n"
"2\n"
"3\n"
"5\n"
"8"
msgstr ""
">>> # Fibonacci series:\n"
">>> # the sum of two elements defines the next\n"
">>> a, b = 0, 1\n"
">>> while a < 10:\n"
"...     print(a)\n"
"...     a, b = b, a+b\n"
"...\n"
"0\n"
"1\n"
"1\n"
"2\n"
"3\n"
"5\n"
"8"

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 ਦੀ ਤਰ੍ਹਾਂ, ਕੋਈ ਵੀ ਗੈਰ-ਜ਼ੀਰੋ ਪੂਰਨ ਅੰਕ ਮੁੱਲ ਸਹੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ; ਜ਼ੀਰੋ ਗਲਤ ਹੁੰਦਾ "
"ਹੈ। ਸ਼ਰਤ ਇੱਕ 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"
">>> print('The value of i is', i)\n"
"The value of i is 65536"
msgstr ""
">>> i = 256*256\n"
">>> print('The value of i is', i)\n"
"The value of i is 65536"

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"
">>> while a < 1000:\n"
"...     print(a, end=',')\n"
"...     a, b = b, a+b\n"
"...\n"
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"
msgstr ""
">>> a, b = 0, 1\n"
">>> while a < 1000:\n"
"...     print(a, end=',')\n"
"...     a, b = b, a+b\n"
"...\n"
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"

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 "ਟਿੱਪਣੀ"