3. Python ਨਾਲ ਇੱਕ ਗੈਰ-ਰਸਮੀ ਜਾਣ-ਪਛਾਣ

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

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

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

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

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

3.1. ਕੈਲਕੂਲੇਟਰ ਵਜੋਂ Python ਦੀ ਵਰਤੋਂ

ਆਓ ਕੁਝ ਸਧਾਰਣ Python commands ਅਜ਼ਮਾਈਏ। interpreter ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਮੁੱਖ prompt >>> ਦੀ ਉਡੀਕ ਕਰੋ। (ਇਸ ਵਿੱਚ ਜ਼ਿਆਦਾ ਸਮਾਂ ਨਹੀਂ ਲੱਗਣਾ ਚਾਹੀਦਾ।)

3.1.1. ਸੰਖਿਆਵਾਂ

interpreter ਇੱਕ ਸਧਾਰਣ calculator ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ: ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਕੋਈ expression ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ ਇਹ ਉਸਦਾ ਮੁੱਲ ਦਿਖਾਏਗਾ। Expression ਦਾ syntax ਸਿੱਧਾ ਹੈ: +, -, * ਅਤੇ / operators ਗਣਿਤੀ ਕਾਰਵਾਈਆਂ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ; brackets () ਸਮੂਹਬੰਦੀ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ:

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating-point number
1.6

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

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

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

ਪਾਇਥਨ ਵਿੱਚ ਘਾਤਾਂ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ** operator ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ [1]:

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

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

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

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

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

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

>>> 4 * 3.75 - 1
14.0

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

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

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

int ਅਤੇ float ਤੋਂ ਇਲਾਵਾ, Python ਹੋਰ ਸੰਖਿਆਤਮਕ ਕਿਸਮਾਂ ਦਾ ਵੀ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ Decimal ਅਤੇ Fraction। Python ਵਿੱਚ complex numbers ਲਈ ਵੀ built-in ਸਮਰਥਨ ਹੈ ਅਤੇ imaginary ਭਾਗ ਦਰਸਾਉਣ ਲਈ j ਜਾਂ J suffix ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ (ਉਦਾਹਰਨ: 3+5j)।

3.1.2. ਪਾਠ

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

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"  # double quotes
'Paris rabbit got your back :)! Yay!'
>>> '1975'  # digits and numerals enclosed in quotes are also strings
'1975'

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

>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

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

>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), special characters are included in the string
'First line.\nSecond line.'
>>> print(s)  # with print(), special characters are interpreted, so \n produces new line
First line.
Second line.

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

>>> print('C:\this\name')  # here \t means tab, \n means newline
C:      his
ame
>>> print(r'C:\this\name')  # note the r before the quote
C:\this\name

Raw strings ਨਾਲ ਇੱਕ ਸੁਖਮ ਗੱਲ ਜੁੜੀ ਹੋਈ ਹੈ: ਕੋਈ raw string \ ਅੱਖਰਾਂ ਦੀ ਵਿਸਮ ਗਿਣਤੀ ਨਾਲ ਸਮਾਪਤ ਨਹੀਂ ਹੋ ਸਕਦੀ। ਹੋਰ ਜਾਣਕਾਰੀ ਅਤੇ ਹੱਲਾਂ ਲਈ the FAQ entry ਵੇਖੋ।

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

>>> print("""\
... Usage: thingy [OPTIONS]
...      -h                        Display this usage message
...      -H hostname               Hostname to connect to
... """)
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

>>>

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

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

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

>>> 'Py' 'thon'
'Python'

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

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

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

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

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

>>> prefix + 'thon'
'Python'

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

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

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

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

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

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

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

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

>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'on'

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

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

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

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

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

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

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

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

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

>>> word[4:42]
'on'
>>> word[42:]
''

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

>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

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

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

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

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

See also

Text Sequence Type --- str

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

String Methods

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

f-strings

ਅਜਿਹੀਆਂ string literals ਜਿਨ੍ਹਾਂ ਵਿੱਚ expressions ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।

Format string syntax

str.format() ਨਾਲ ਸਟਰਿੰਗ ਫਾਰਮੈਟਿੰਗ ਬਾਰੇ ਜਾਣਕਾਰੀ।

printf-style String Formatting

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

3.1.3. ਸੂਚੀਆਂ

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

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

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

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

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

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

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

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

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

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

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

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba)  # they reference the same object
True
>>> rgba.append("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]

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

>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
>>> rgba
["Red", "Green", "Blue", "Alph"]

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

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

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

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

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

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

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

ਬੇਸ਼ੱਕ, ਅਸੀਂ Python ਨੂੰ ਸਿਰਫ਼ ਦੋ ਅਤੇ ਦੋ ਜੋੜਨ ਨਾਲੋਂ ਕਾਫ਼ੀ ਜ਼ਿਆਦਾ ਜਟਿਲ ਕੰਮਾਂ ਲਈ ਵਰਤ ਸਕਦੇ ਹਾਂ। ਉਦਾਹਰਨ ਵਜੋਂ, ਅਸੀਂ Fibonacci series ਦਾ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਉਪ-ਕ੍ਰਮ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖ ਸਕਦੇ ਹਾਂ:

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

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

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

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

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

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

  >>> i = 256*256
  >>> print('The value of i is', i)
  The value of i is 65536
  

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

  >>> a, b = 0, 1
  >>> while a < 1000:
  ...     print(a, end=',')
  ...     a, b = b, a+b
  ...
  0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
  

ਫੁੱਟਨੋਟ

[1]

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

[2]

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