Lesson 06: Python Syntax

Python uses a technique called Name Mangling . By this technique, and only by selecting the identifiers, they are given a special role:

• Private ID Module: If an ID _starts (not ends) with a character, it is evaluated by the Python interpreter in this role. Such as: name_(and not: _name_or _name)
• Private Class Id: If an ID with two characters _begins (rather than ends), it is evaluated by the Python interpreter in this role. Such as: name__(and not: __name__or __name)

Apart from this, in Python there are certain attributes and methods that are predefined and have a specific meaning for the interpreter. The identifier of these attributes and methods _begins and ends with two characters ; Just like attributes __class__and __doc__previously used.

Therefore _, we must be sufficiently aware when using the character in the ID (especially at the beginning). [The issues will be addressed in the future.]

For single-character identifiers, be sure to avoid the letters l (lowercase) and I (upper case), as these two letters are similar in some fonts, as well as the letter O (uppercase), which can be zero.

>>> # Python 3.x

>>> help("keywords")
Here is a list of the Python keywords.  Enter any keyword to get more help.

False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not
class               from                or
continue            global              pass

>>> # Python 2.x

>>> help("keywords")
Here is a list of the Python keywords.  Enter any keyword to get more help.

and                 elif                if                  print
as                  else                import              raise
assert              except              in                  return
break               exec                is                  try
class               finally             lambda              while
continue            for                 not                 with
def                 from                or                  yield
del                 global              pass

There is a module in the standard Python library called keyword [Python Documents ]:

>>> # Python 3.x

>>> import keyword

>>> keyword.iskeyword(a)
False

>>> keyword.iskeyword("def")
True

>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

You may be curious to know the number of Python keywords; You do not need to count manually for this purpose !:

>>> # Python 3.x
>>> import keyword
>>> len(keyword.kwlist)
33

>>> # Python 2.x
>>> import keyword
>>> len(keyword.kwlist)
31

Variable

A ” variable ” in most programming languages, such as C, indicates a location in memory in which a value is stored. Consider the following three commands, for example:

int a = 1;

a = 2;

int b = a;

In the example code above: the command; int a = 1 states that a memory location called a should be considered for storing integers and the value 1 should be there; From now on, the variable a represents this point in memory (just like a box) that now contains the value 1 (Figure below – one). Then the command; a = 2 causes the previous value of the variable a to be removed (out of the box) and the new value of 2 to be placed in it (bottom figure – two). Note that in this category of languages, the type is specified by the variable, and attempting to insert a data type other than int into the variable a (such as 3.7 or “string”) causes a compilation error. Third command: ‌; int b = a first creates a new location in memory called b of the same integer type and then copies the value inside the variable a into it; There are now two places to store the int data type in memory, both of which contain a value of 2 (Figure 3 below).

The interpreter performs the following three steps upon reaching the command :a = 1

1. Creates an object of type integers and values 1 somewhere in memory. Why integers? The type is determined by the object and the 1 number is correct!
2. Creates the variable a (or the same name) elsewhere in the memory (if it has not already been created).
3. Establishes a link from the variable ato the object 1. This link is called “Reference” which is implemented as a pointer in memory.

Each object contains a ” counter-reference » (Reference Counter) as well; In this way, it shows the number of references to that object at each moment, and with each new reference to the object, one unit is added to it, and by deleting each reference, one unit decreases. If its value reaches zero, the object is cleared by the ” Garbage Collection ” technique and the amount of memory consumed by the object is released. The function ()getrefcountinside the module syscan be used to view the number of references to an object [ Python Documents ].

>>> import sys

>>> a = 1
>>> sys.getrefcount(1)
760

>>> a = 2
>>> sys.getrefcount(1)
759
>>> sys.getrefcount(2)
96

>>> b = a
>>> sys.getrefcount(2)
97

Multiple Assignment 

It is possible to create multiple variables or multiple assignments in Python at the same time – you can create multiple variables, all of which refer to the same object:

>>> a = b = c = "python"

>>> a

'python'

>>> b

'python'

>>> c

'python'

To assign different objects we must use a comma and only one assignment operator ( =) – note that the number of elements on both sides of the assignment operator must be equal:

>>> a, b, c, d = 1, 4.5, "python", 2

>>> a
1

>>> b
4.5

>>> c
'python'

>>> d
2

One of the uses of multiple assignments is that two variable objects can be easily swapped with just one command line:

>>> a = 1
>>> b = 2

>>> a, b = b, a

>>> a
2
>>> b
1

Fixed 

” Constant ” is a variable whose value is always constant and after the definition, it is no longer possible to change its value. For example, a constant in Java is defined as follows – after the following command, any attempt to change the constant value HOURSwill encounter an error:

In Python, there is no possibility of a fixed definition!

In addition to the possibility of creating constants, there are some other things that are overlooked in Python. In fact, Python assumes that its users are smart people who can handle problems; “I trust my users, so I don’t have to do everything for them, a programmer has to be able to take risks,” he says.

But to create a constant, you can define your desired variables in a separate module and import access the variables you want with it wherever necessary :

# File: constant.py
# Path: /home/kazem/Documents/MyModule

HOURS = 24

>>> import sys
>>> sys.path.append('/home/kazem/Documents/MyModule')

>>> import constant
>>> constant.HOURS
24

Of course, if the immutability of the variables is of particular importance to you, you can create a module containing the following code [ Source ]:

# File: constant.py
# Path: /home/kazem/Documents/MyModule

class _const:

class ConstError(TypeError): pass

def __setattr__(self, name, value):
if name in self.__dict__:
raise self.ConstError("Can't rebind const(%s)" % name)
self.__dict__[name] = value

import sys
sys.modules[__name__] = _const()

Understanding class code const_requires studying class lessons and Exceptions. But for a brief explanation in this lesson, it should be said that:

Operators

” Operator ” is a symbol that performs a specific action on objects; Like the assignment operator =discussed earlier. Objects on which the operator performs an action are also called ” operands “. There are different types of operators, which we will examine below.

1. Arithmetic Operators:+ - * ** / // %

• +Addition: Adds the amount of operands on both sides together. 2 + 1 Result: 3

• -Subtraction: Subtracts the value of the right operand from the value of the left operand:4 - 7 Result: 3

• *Multiplication: Multiplies the amount of operands on both sides: 2 * 5 Result: 10

• **Power (Exponent): Increases the value of the left operand to the power of the value of the right operand. 3 ** 2 Result: 8

• / Division: Divides the value of the left operand by the value of its right operand and returns the outside of the part:

>>> # Python 3.x              >>> # Python 2.x

>>> 7 / 3                     >>> 7 / 3
2.3333333333333335            2
>>> 12 / 3                    >>> 12 / 3
4.0                           4
>>> 6.0 / 2                   >>> 6.0 / 2
3.0                           3.0

As seen in the sample code above; In 3x versions, the result of each division is always calculated as a decimal number, but in 2x versions, the result of dividing two integers is calculated as an integer in the same way and the decimal value (if any) is omitted. This feature can be added to 2x versions below [ Python Documents ]:

>>> # Python 2.x

>>> from __future__ import division

>>> 7 / 3
2.3333333333333335

>>> 12 / 3
4.0

• //Floor Division: Divides the value of the left operand by the value of its right operand and returns the outside by removing the decimal value (if any). The result of this operator is calculated as an integer for integers, note the results of the sample code below:

>>> # Python 3.x              >>> # Python 2.x

>>> 7 // 3                    >>> 7 // 3
2                             2
>>> 12 // 3                   >>> 12 // 3
4                             4
>>> 6.0 // 2                  >>> 6.0 // 2
3.0                           3.0
>>> 7.0 // 3                  >>> 7.0 // 3
2.0                           2.0

• %Residual (Modulus): Divides the value of the left operand by the value of its right operand and returns the remainder. Result: 13 % 7

2. Comparison Operators:== =! <> < > =< =>

• ==Equal: Returns if the values ​​of the operands on both sides are equal True. : False1 == 3
• =!Not Equal: Returns if the values ​​of the operands on both sides are not equal True. : True1 =! 3
• <>Not Equal: It works the same =!but can only be used in the 2x version of Python. : True1 <> 3
• <Greater Than: Returns if the value of the left operand is greater than the value of the right operand True. : False5 < 3
• >Less Than (Less Than): Returns if the value of the left operand is less than the value of the right operand True. : True5 > 3
• =<Greater Than or Equal: Returns if the value of the left operand is equal to or greater than the value of the right operand True. : True5 =< 7
• =>Less Than or Equal: Returns if the value of the left operand is equal to or less than the value of the right operand True. : False5 => 7

3. Assignment Operators:

• =Attributes the right operand to its left operand. If a computational expression is on the right, it attributes the result to the operand on the left:

  >>> a = 3
  
  >>> b = 2
  
  >>> c = a + b
  >>> c
  5
  

• =+ =- =* =** =/ =// =% Combined operators (arithmetic assignment): These operators first perform the arithmetic operator operation on the value of the operands on both sides and then attribute the result to the left operand:

  >>> a += b
  >>> a
  5
  

  >>> a -= b
  >>> a
  1
  

  >>> a *= b
  >>> a
  6
  

  >>> a **= b
  >>> a
  9
  

  >>> # Python 3.x                  >>> # Python 2.x
  >>> a /= b                        >>> a /= b
  >>> a                             >>> a
  1.5                               1
  

4. Bitwise Operators:& | ^ ~ >> <<

These operators perform a specific operation on each of the operative bits (s). In Python, to use these operators, it is not necessary to convert numbers to base two (binary), but here we have used binary numbers to better see how they work. In Python, two base numbers must always 0bstart with one :

>>> a = 0b0011
>>> a
3
>>> b = 0b0010
>>> b
2

The function ()bincan be used to obtain the binary value of a decimal number; Note, however, that this function returns a binary value in text format (String type) – Another point is that in Python interactive mode, entering binary numbers gives a decimal output:

>>> bin(10)
'0b1010'

>>> type(bin(10))
<class 'str'>

>>> 0b1010
10

• &: AND is equivalent to a bit – only the output bits 1will be that both bits correspond to its operands 1:

  >>> a & b                  0000 0011
  2                          0000 0010
                      (AND) -----------
                             0000 0010  = 2
  

• |: OR is equivalent to a bit – only the output bits 0will be that both bits correspond to its operands 0:

  >>> a | b                  0000 0011
  3                          0000 0010
                       (OR) -----------
                             0000 0011  = 3
  

• ^: XOR is equivalent to a bit – only the output bits 1will be if both corresponding bits of its operands are opposite each other:

  >>> a ^ b                  0000 0011
  1                          0000 0010
                      (XOR) -----------
                             0000 0001  = 1
  

• ~Is NOT equivalent to single-bit operands – each bit of its operand converts from 0to 1and vice versa:

  >>> ~ a                    0000 0011
  -4                  (NOT) -----------
                             1111 1100
  

  One way to display binary notation numbers is to invert the bits (0 to 1 and 1 to 0), called the ” One’s Complement ” display of binary numbers. But the Python interpreter by default evaluates symbolic numbers in a more common way known as the Two’s Complement ; In this method, after the bits are inverted, the result is added to the number 1. Therefore, in the example of the above code, the result of the NOTnumber is aequal 11111100, which is the representation of the number in base two in a complementary way:4 -

  n = 3                       0000 0011
  3 = 0000 0011        (NOT) -----------
                              1111 1100  = -3 (in One’s Complement)
                                         = -4 (in Two’s Complement)
  

  Two’s Complement
  
  n = 4                       0000 0100
  4 = 0000 0100        (NOT) -----------
                              1111 1011
                                      1
                       ( + ) -----------
                              1111 1100  = -4
  

  The value can be considered equal to the product of the expression. Thus:a ~1 - a-

  >>> ~ a + 1
  -3
  

• >>Left Shift: Moves the left operand bits to the value of its right operand to the left – the rejected locations are set to zero:

  >>> a << 3                  0000 0011
  24                   (LSH) -----------
                              0001 1000  = 24
  

• <<Right Shift: Moves the left operand bits to the value of its right operand to the right – the rejected locations are set to zero:

  >>> a = 88                  0101 1000
  >>> a >> 3           (RSH) -----------
  11                          0000 1011  = 11
  

• =& =| =^ =>> =<< Combined operators (bit assignment): These operators first perform the bit operator operation on the operands on both sides and then attribute the result to the left operand.

5. Logical Operators:

These operators are not or andused in conditional statements. Logical operators evaluate their operations based on True(true) and False(incorrect) values and return their results based on the table below. It is a notsingle operand operator.

The operator returns andonly when both operands have a True value True. The operator returns oronly when both operands have a False value False. The operator notalso reverses its operating value (True to False and False to True).

6. Membership Operators:

Includes both operators inand that they check for an amount among the members of a sequence (sequence such as strings, lists, etc.) are used.not in

• in: If the value of the left operand finds itself in the right operand , Trueand Falsereturns otherwise .
• not in: If the value of the left operand does not find itself in the right operand , Trueotherwise Falsereturns.

>>> "py" in "python"
True
>>> 1 in [1, 2, 3]
True
>>> "s" not in "python"
True
>>> 3 not in [1, 2, 3]
False

7. Identity Operators:

Includes both operator isand that they are used to check one of the two objects.is not

• isIf both operands reference to an object to be, Trueand otherwise Falsereturns.
• is not: If both operands do not refer to the same object , Trueotherwise Falsereturns.

>>> a = 3

>>> a is 3
True

Priorities

If a phrase contains multiple operators; Which action is examined first will have an impact on the outcome. Each of the operators has a priority that must be considered in order. At the bottom we will examine the priority of the operators – the priority is reduced from top to bottom:

()                         # Brackets
**
~
-              +                   # Negative and positive
*              /                     //                            %
-              +                   # plus and minus
<<             >>
&amp;              ^                   |
==!            =           <>
<              <              =>           >=
=             **=          /=               //     =% =    *=      -=      +=
is             is not
in              in not
not               and or

The parentheses have the highest priority, meaning that each phrase contained in it will have a higher priority for review; In nested parentheses, the innermost parentheses are the highest priority. If an expression contains several level operators; The operator’s priority is on the left. Note the following statements and their results:

>>> # Python 3.x

>>> 4 + 2 - 3 + 2 * 5
13

>>> 4 + ((2 - 3) + 2) * 5
9

>>> 9 / 3 * 2
6.0

>>> 3 * 2 / 9
0.6666666666666666

>>> (5 - 3) ** (7 - 3)
16

>>> 4 + 3 ** 2 - 9 / 3 * 3
4.0

>>> 4 * 2 == 5 + 3
True