Python Basics

Beginner friendly, simple to read, Interpreted, Dynamically typed

Python Hello World

print ("Hello world")

Hello world

Python variables

a=3

print (a)

True

print ("Type of a -> ", type(a))

Type of a ->  <class 'int'>

Maximum possible value of an integer in python?

a = 10000000000000000000000000000000000000000000
b = 1
a+b

10000000000000000000000000000000000000000001

b = 4.555
print (b)

4.555

print ("Type of b -> ", type(b))

Type of b ->  <class 'float'>

c = "Python"
print (c)

Python

print ("Type of c -> ", type(c))

Type of c ->  <class 'str'>

d = 'p'
print (d)

p

print ("Type of d -> ", type(d))

Type of d ->  <class 'str'>

d = 3+8j
print (d)

(3+8j)

print ("Type of d -> ", type(d))

Type of d ->  <class 'complex'>

e = True
print ("Type of e -> ", type(e))

Type of e ->  <class 'bool'>

Python Math operators

+ -> Addition: adds two operands

a = 9
b = 8
a+b

17

a = "Python"
b = "Programming"
a+b

'PythonProgramming'

a = 3
b = "python"
a+b

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-143-6e8d2664dc48> in <module>()
      1 a = 3
      2 b = "python"
----> 3 a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

a = 9.8
b = 9
a+b

18.8

a = "python"
c = 'l'
a+c

'pythonl'

- -> Subtraction: subtracts two operands

a = 9
b = 8
a-b

1

a = "PythonProgramming"
b = "Python"
a-b

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-147-f693bab7eb86> in <module>()
      1 a = "PythonProgramming"
      2 b = "Python"
----> 3 a-b

TypeError: unsupported operand type(s) for -: 'str' and 'str'

a = 0.333333
b = 4.222221
a-b

-3.888888

* -> Multiplication: multiplies two operands

a = 3.4444
b = 3
a*b

10.3332

a = "python"
b = "programming"
a*b

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-150-41081f0d5590> in <module>()
      1 a = "python"
      2 b = "programming"
----> 3 a*b

TypeError: can't multiply sequence by non-int of type 'str'

a = 3
b = "python"
a*b

'pythonpythonpython'

a = "python"
b = 3
a*b

'pythonpythonpython'

/ -> Division (float): divides the first operand by the second

a = 9
b = 4
a/b

2.25

// Division (floor): divides the first operand by the second

a = 9
b = 4
a//b

2

% Modulus: returns the remainder when first operand is divided by the second

a = 17
b = 5
a%b

2

a = 17.9
b = 5
a%b

2.8999999999999986

** -> Exponent

a = 5
b = 2
a**2

25

a = 9.6
b = 0.9
a**b

7.656743697665163

a = "hi"
b = 2
a**b

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-205-e843df7360da> in <module>()
      1 a = "hi"
      2 b = 2
----> 3 a**b

TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

Relational Operators

a = 80
b = 90
print ("a>b : ", a>b)
print ("a<b : ", a<b)

a>b :  False
a<b :  True

a = "python"
b = "programming"
a>b

True

Strings are compared lexicographically

== -> Equal to: True if both operands are equal

a = 90
b = 90
print (a==b)
a = "hi"
b = "hi"
c = b
print (a==c)
a = "hi"
b = "Hi"
print (a==b)
a = 90.999997
b = 90.999998
print (a==b)
a = 9.9999999999999999993
b = 9.9999999999999999994
print (a==b)

True
True
False
False
True

a = "python"
b = 0
print (a!=b)

True

a = "python"
b = 90
print (a>=b)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-67-1d22cc6400ed> in <module>()
      1 a = "python"
      2 b = 90
----> 3 print (a>=b)

TypeError: '>=' not supported between instances of 'str' and 'int'

a = 100
b = 100.01
print (a<=b)

True

Logical operators ( and, or , not)

a = True
b = False
c = 0
d = 90
e = -9
print (a and b)
print (a or b)
print (not b)
print (not c)
print (not d)
print (not e)
print (c and e)
print (d and e)
print (e and d)
print (e and not d)

False
True
True
True
False
False
0
-9
90
False

Iteration, for loop, Range

for i in range(10):
    print (i)

0
1
2
3
4
5
6
7
8
9

#Print from 5 to 9
for i in range(5,10):
    print (i)

5
6
7
8
9

for i in range(1,10,2):
    print (i)

1
3
5
7
9

for i in range(1,-10):
    print (i)

for i in range(1,-10, -2):
    print (i)

1
-1
-3
-5
-7
-9

Lists

l = [1,2,3]
print ("Type of l : ",type(l))

Type of l :  <class 'list'>

l = ["python", "programming", "is", "fun"]
print (l)

['python', 'programming', 'is', 'fun']

l = [1, "py", 3.4, True]
print (l)

[1, 'py', 3.4, True]

l1 = ["python", "programming", "session"]
l2 = l1
print (l2)
l2[1]="basics"
print (l1)
l1 = [0,9,8]
print ("l1 = ",l1)
print ("l2 = ", l2)

['python', 'programming', 'session']
['python', 'basics', 'session']
l1 =  [0, 9, 8]
l2 =  ['python', 'basics', 'session']

Slicing

l = [1,2,3,4,5,6,7,8,9,10]
l

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print ("l[0:3] -> ", l[0:3])
print ("l[9:3] -> ", l[9:3])
print ("l[2:2] -> ", l[2:2])
print ("l[2:20] -> ", l[2:20])
print ("l[2:] -> ", l[2:])
print ("l[:2] -> ", l[:2])
print ("l[-1:-3] -> ", l[-1:-3])
print ("l[-3:-1] -> ", l[-3:-1])
print ("l[-4:-1] -> ", l[-4:-1])
print ("l[:-1] -> ", l[:-1])
print ("l[-1:] -> ", l[-1:])
print ("l[0:5:2] -> ", l[0:5:2])
print ("l[-6:-1:-2] -> ", l[-6:-1:-2])
print ("l[-6:-1:2] -> ", l[-6:-1:2])
print ("l[6:0:-2] -> ", l[6:0:-2])
print ("l[::2] -> ", l[::2])

l[0:3] ->  [1, 2, 3]
l[9:3] ->  []
l[2:2] ->  []
l[2:20] ->  [3, 4, 5, 6, 7, 8, 9]
l[2:] ->  [3, 4, 5, 6, 7, 8, 9]
l[:2] ->  [1, 2]
l[-1:-3] ->  []
l[-3:-1] ->  [7, 8]
l[-4:-1] ->  [6, 7, 8]
l[:-1] ->  [1, 2, 3, 4, 5, 6, 7, 8]
l[-1:] ->  [9]
l[0:5:2] ->  [1, 3, 5]
l[-6:-1:-2] ->  []
l[-6:-1:2] ->  [4, 6, 8]
l[6:0:-2] ->  [7, 5, 3]
l[::2] ->  [1, 3, 5, 7, 9]

Assignment using slicing

l = [9,8,7,6,5,4,3,2,1]
l[0]=99
l

[99, 8, 7, 6, 5, 4, 3, 2, 1]

l[0:2]=90,80
l

[90, 80, 7, 6, 5, 4, 3, 2, 1]

l[-3:-1] = [30,20]
l

[90, 80, 7, 6, 5, 4, 30, 20, 1]

l[4:6]=90
l

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-167-b9f73dc13a2b> in <module>()
----> 1 l[4:6]=90
      2 l

TypeError: can only assign an iterable

l[2:3]="p"
l

[90, 80, 'p', 6, 5, 4, 30, 20, 1]

l[3:6]=[]
l

[90, 80, 'p', 30, 20, 1]

l[-1] = 10
l

[90, 80, 'p', 30, 20, 10]

List Iteration

l = [1,2,3,4,5,6,7,8,9]
#Add all elements in the list
acc = 0
for i in range(len(l)):
    acc += l[i]
acc

45

l = [1,2,3,4,5,6,7,8,9]
#Add all elements in the list
acc = 0
for i in l:
    acc += i
acc

45

l = [1,2,3,4,5,6,7,8,9]
#Add all elements in the list
acc = 0
for i in l[0:5]:
    acc += i
acc

15

#Print alternate elements
l = [1,2,3,4,5,6,7,8,9]
for i in l[0::2]:
    print (i)

1
3
5
7
9

List Comprehension

l1 = []
for i in range(10):
    l1.append(i)
l1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

l2 = [i for i in range(10)]
l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

List Comprehension with conditions

#Get a list of integers divisible by 3 
l3 = [i for i in range(10) if i%3==0]
l3

[0, 3, 6, 9]

#Using if else
l = ['d','g','r','e','s','j','q','t','i']
vowels = ['a', 'e', 'i', 'o', 'u']
l4 = ["Vowel" if i in vowels else "Consonant" for i in l]
l4

['Consonant',
 'Consonant',
 'Consonant',
 'Vowel',
 'Consonant',
 'Consonant',
 'Consonant',
 'Consonant',
 'Vowel']

l1 = [1,2,3]
l2 = [4,5,6]
#Multiply both the list using for loops
l3 = []
for i in l1:
    for j in l2:
        l3.append(i*j)
l3

[4, 5, 6, 8, 10, 12, 12, 15, 18]

#Nested List comprehension
l1 = [1,2,3]
l2 = [4,5,6]
l3 = [i*j for j in l1 for i in l2]
l3

[4, 5, 6, 8, 10, 12, 12, 15, 18]

#Nested List comprehension
l1 = [[1,2,3], [4,5,6], [7,8,9]]
#print all the elements as single list
l2 = [i for j in l1 for i in j]
l2

[1, 2, 3, 4, 5, 6, 7, 8, 9]