All the IPython Notebooks in this lecture series are available at https://github.com/rajathkumarmp/Python-Lectures

In [1]:

```
import this
```

A name that is used to denote something or a value is called a variable. In python, variables can be declared and values can be assigned to it as follows,

In [2]:

```
x = 2
y = 5
xy = 'Hey'
```

In [3]:

```
print x+y, xy
```

Multiple variables can be assigned with the same value.

In [4]:

```
x = y = 1
```

In [5]:

```
print x,y
```

Symbol | Task Performed |
---|---|

+ | Addition |

- | Subtraction |

/ | division |

% | mod |

* | multiplication |

// | floor division |

** | to the power of |

In [6]:

```
1+2
```

Out[6]:

In [7]:

```
2-1
```

Out[7]:

In [8]:

```
1*2
```

Out[8]:

In [9]:

```
1/2
```

Out[9]:

0? This is because both the numerator and denominator are integers but the result is a float value hence an integer value is returned. By changing either the numerator or the denominator to float, correct answer can be obtained.

In [10]:

```
1/2.0
```

Out[10]:

In [11]:

```
15%10
```

Out[11]:

Floor division is nothing but converting the result so obtained to the nearest integer.

In [12]:

```
2.8//2.0
```

Out[12]:

Symbol | Task Performed |
---|---|

== | True, if it is equal |

!= | True, if not equal to |

< | less than |

> | greater than |

<= | less than or equal to |

>= | greater than or equal to |

In [13]:

```
z = 1
```

In [14]:

```
z == 1
```

Out[14]:

In [15]:

```
z > 1
```

Out[15]:

Symbol | Task Performed |
---|---|

& | Logical And |

l | Logical OR |

^ | XOR |

~ | Negate |

>> | Right shift |

<< | Left shift |

In [16]:

```
a = 2 #10
b = 3 #11
```

In [17]:

```
print a & b
print bin(a&b)
```

In [18]:

```
5 >> 1
```

Out[18]:

0000 0101 -> 5

Shifting the digits by 1 to the right and zero padding

0000 0010 -> 2

In [19]:

```
5 << 1
```

Out[19]:

0000 0101 -> 5

Shifting the digits by 1 to the left and zero padding

0000 1010 -> 10

Python comes loaded with pre-built functions

Conversion from hexadecimal to decimal is done by adding prefix **0x** to the hexadecimal value or vice versa by using built in **hex( )**, Octal to decimal by adding prefix **0** to the octal value or vice versa by using built in function **oct( )**.

In [20]:

```
hex(170)
```

Out[20]:

In [21]:

```
0xAA
```

Out[21]:

In [22]:

```
oct(8)
```

Out[22]:

In [23]:

```
010
```

Out[23]:

**int( )** accepts two values when used for conversion, one is the value in a different number system and the other is its base. Note that input number in the different number system should be of string type.

In [24]:

```
print int('010',8)
print int('0xaa',16)
print int('1010',2)
```

**int( )** can also be used to get only the integer value of a float number or can be used to convert a number which is of type string to integer format. Similarly, the function **str( )** can be used to convert the integer back to string format

In [25]:

```
print int(7.7)
print int('7')
```

Also note that function **bin( )** is used for binary and **float( )** for decimal/float values. **chr( )** is used for converting ASCII to its alphabet equivalent, **ord( )** is used for the other way round.

In [26]:

```
chr(98)
```

Out[26]:

In [27]:

```
ord('b')
```

Out[27]:

**round( )** function rounds the input value to a specified number of places or to the nearest integer.

In [28]:

```
print round(5.6231)
print round(4.55892, 2)
```

**complex( )** is used to define a complex number and **abs( )** outputs the absolute value of the same.

In [29]:

```
c =complex('5+2j')
print abs(c)
```

**divmod(x,y)** outputs the quotient and the remainder in a tuple(you will be learning about it in the further chapters) in the format (quotient, remainder).

In [30]:

```
divmod(9,2)
```

Out[30]:

**isinstance( )** returns True, if the first argument is an instance of that class. Multiple classes can also be checked at once.

In [31]:

```
print isinstance(1, int)
print isinstance(1.0,int)
print isinstance(1.0,(int,float))
```

**cmp(x,y)**

x ? y | Output |
---|---|

x < y | -1 |

x == y | 0 |

x > y | 1 |

In [32]:

```
print cmp(1,2)
print cmp(2,1)
print cmp(2,2)
```

**pow(x,y,z)** can be used to find the power $x^y$ also the mod of the resulting value with the third specified number can be found i.e. : ($x^y$ % z).

In [33]:

```
print pow(3,3)
print pow(3,3,5)
```

**range( )** function outputs the integers of the specified range. It can also be used to generate a series by specifying the difference between the two numbers within a particular range. The elements are returned in a list (will be discussing in detail later.)

In [34]:

```
print range(3)
print range(2,9)
print range(2,27,8)
```

**raw_input( )** accepts input and stores it as a string. Hence, if the user inputs a integer, the code should convert the string to an integer and then proceed.

In [35]:

```
abc = raw_input("Type something here and it will be stored in variable abc \t")
```

In [36]:

```
type(abc)
```

Out[36]:

**input( )**, this is used only for accepting only integer inputs.

In [37]:

```
abc1 = input("Only integer can be stored in variable abc \t")
```

In [38]:

```
type(abc1)
```

Out[38]:

Note that **type( )** returns the format or the type of a variable or a number