Pages

Saturday, April 29, 2017

Python Practice


#  Character Input Solution
name = input("Enter you name: ")
print("You name is: "+ name)

# Divisors Solutions
num = int(input("Enter the valid number: "))
divlst = []
for n in list(range(1,num+1)):
    if num % n == 0:
        divlst.append(n)
print(divlst)

# find even list
a = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
evenlst = []
for num in a:
    if num % 2 == 0:
        evenlst.append(num)

print("the new even list is", evenlst)
or
evenlst = [number for number in a if number % 2 == 0]
print("the new even list is", evenlst)

# fibonacci series
def fib(num):
    n1 = 0
    n2 = 1
    count = 0
    if num <= 0:
        print("Pelase enter positive number")
    elif num == 1:
        print("fibanacci series upto :", num , ":", n1)
    else:
        print('fibanacci series upto :', num , "is :")
    while count < num:
        print( n1, end= " ")
        n3 = n1 + n2
        n1 = n2
        n2 = n3
        count += 1
     
fib(5)

# print list having numbers less than 10
a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
numlst = []
for num in a:
    if num < 10:
        numlst.append(num)

print(numlst)

or
>>> numlst = [num for num in a if num < 10]
>>> numlst

[1, 1, 2, 3, 5, 8]

# find common elements between two lists
a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
# first convert the list to set
a = set([1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89])
print(type(a))
b = set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13])
print(type(b))
res = a.intersection(b)
print("common elements: ", res)

or

>>> a = set(a)
>>> a
{1, 2, 3, 34, 5, 8, 13, 21, 55, 89}
>>> 
>>> b = set(b)
>>> b
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
>>> 
>>> res = a.intersection(b)
>>> res

{1, 2, 3, 5, 8, 13}


# find max of three values
def max_3(a,b,c):
    if (a>b) and (a>c):
        return a
    if (b>a) and (b>c):
        return b
    if (c>a) and (c>b):
        return c
print("Max value is : ", max_3(7,3,9))

# find new list having 1st and last element
newlst = []
def test(lst):
    newlst.append(lst[0])
    newlst.append(lst[-1])
    print(newlst)
lst = [1,2,3,4,5,6,7]
test(lst)

# find odd or even number
num = int(input("Enter the number "))
if num %2 == 0:
    print(num, "is the even number")
else:
    print( num, "is the odd number")

# find if element is present in given list
def find(ordered_list, element_to_find):
    for element in ordered_list:
        if element == element_to_find:
            return True
    return False

l = [1,2,3,4,5]
print(find(l,10))

or

>>> def find(num, lst):
...     if num in lst:
...             return True
...     else:
...             return False
... 
>>> lst = [1,2,3,4,5]
>>> find(2,lst)
True
>>> 
>>> find(10,lst)
False

>>> 

# find if given string is palindrome
name = input("Enter the string: ")
if name[::] == name[::-1]:
    print(name, "is a palindrome")
else:
    print(name, "is not a palindrome")

# find if number is prime or not
num = int(input("Enter a number: "))
if num %2 != 0 or num == 1:
    print(num , "is a prime number")
else:
    print(num, "is not a prime number")

# find the sum of two numbers
a = input ("Enter the value of a : ")
b = input ("Enter the value of b : ")
## by default input takes a string
res = int(a) + int(b)
print("Final ans = ", res)

>>> def sum(a,b):
...     return (a+b)
... 
>>> sum(0.3,5)

5.3

# remove duplicate values.
lst = [1,1,2,3,4,5,4,2,10,15,5,6]
newlst = set(lst)
print(newlst)

# reverse the order
 def rev(str):
    str = input("Enter the sentence: ")
    new = str[::-1]
    print(new)
rev(str)

>>> def rev(str):
...     str = input("Enter the input:" )
...     newstr = str[::-1]
...     print(newstr)
... 
>>> rev("str")
Enter the input: Hello Nawraj How are you?

?uoy era woH jarwaN olleH 

# How to plot graph
import pandas as pd
import matplotlib.pyplot as plt
df = pd.read_csv("studs.csv")
df.plot()
plt.show()

# square of all numbers
numlst = [1,2,3,4,5,6,7,8]
reslst=list(map(lambda x : x*x, numlst))
print(reslst)


>>> res = list(map(lambda x:x*x, numlst))
>>> res

[1, 4, 9, 16, 25, 36, 49, 64]

# find missing number in list
def missing_no(lst):
    #print(range(lst[0],lst[-1]+1))
    return sum(range(lst[0],lst[-1]+1)) -sum(lst)
lst = [1,2,3,5,6]
print(missing_no(lst))



# Verify perfect square number
import math
def is_perfect_square(n):
    return math.sqrt(n).is_integer()
print(is_perfect_square(56))

# compute power of 2

import math
def power2(n):
    return math.pow(2,n)
 

print(power2(9))

or

def powerof2(num):
    return ((num & (num - 1)) == 0) and (num != 0) ## bitwise calculation
print(powerof2(8))

# print year and month
import calendar
y = int(input("Input the year: "))
m = int(input("Input the month: "))
print(calendar.month(y,m))

# Write a Python program to convert month name to a number of days.
print("List of months: January, February, March, April, May, June, July, August, September, October, November, December")
month_name = input("Enter the month name: ")
if month_name == "February":
    print("No of days: 28/29 days")
elif month_name in ("April", "June", "September", "November"):
    print("No of days: 30 days")
elif month_name in ("January", "March", "May", "July", "August", "October", "December"):
    print("No of days: 31 days")
else:
    print("Wrong month name")

##  Write a Python program to check a triangle is equilateral, isosceles or scalene
print("Input the lengths of the triangle")
x = input("x:")
y = input("y:")
z = input("z:")
if x == y == z:
    print("equilateral triangle")
elif x != y != z:
    print("scalene triangle")
else:
    print("Isoceles triangle")

# Write a Python program to calculate the sum and average of n integer numbers(input from the user). Input 0 to finish.
print("Input some integers to calculate the sum and average. Input 0 for exit")
sum = 0
count = 0
lst = [1,3,4,5,9]
for n in lst:
    sum += n
    count += 1
if count == 0:
    print("Input some numbers")
else:
    print("Average and sum of numbers: ", sum/count, sum)

## Write a Python program to create the multiplication table (from 1 to 10) of a number
n = int(input("input the number to create multiplication table: "))
for i in range(1,11):
    print(n, 'x', i, "=", n*i)

#remember
n = 5 ## type is int
n = "5" ## type is str

# Write a Python program to construct the following pattern, using a nested loop number
1
22
333
4444
55555
666666
7777777
88888888
999999999

for i in range(1,10):
    print(str(i)*i)

# Write a Python script to concatenate following dictionaries to create a new one
dic = {}
dic1 = {1:10,2:20}
dic2 = {3:30,4:40}
dic3 = {5:50,6:60}
for d in (dic1, dic2, dic3):
    dic.update(d)
print(dic)

# Write a Python program to find those numbers which are divisible by 7 and multiple of 5, between 1500 and 2700 (both included)
lst = []
for n in range(1500,2701):
    if n%7 == 0 and n%5 == 0:
        lst.append(n)
print(lst)

# Write a Python program to guess a number between 1 to 9.
# Note : User is prompted to enter a guess. If the user guesses wrong then the prompt appears again until the guess is correct, on successful guess, user will get a "Well guessed!" message, and the program will exit.
import random
target_num, guess_num = random.randint(1,10), 0
while target_num != guess_num:
    guess_num = int(input('Gues a number between 1 and 9 until u get it right: '))
print('well guessed')

# Write a Python program to construct the following pattern, using a nested for loop.
* * 
* * * 
* * * * 
* * * * * 
* * * * 
* * * 
* * 
*

n = 5
for i in range(5):
    for j in range(i):
        print('* ', end='')
    print("")

for i in range(n,0,-1):
    for j in range(i):
        print("* ", end="")
    print('')

# Write a Python program that accepts a word from the user and reverse it
word = input("Enter the word: ")
res = word[::-1]
print(res)

# Write a Python program to count the number of even and odd numbers from a series of numbers
numbers = (1, 2, 3, 4, 5, 6, 7, 8, 9)
even_num = []
odd_num = []
for n in numbers:
    if n%2 == 0:
        even_num.append(n)
    else:
        odd_num.append(n)
print("Number of even numbers: ", len(even_num))
print("Number of odd numbers: ", len(odd_num))

#or

numbers = (1, 2, 3, 4, 5, 6, 7, 8, 9)
even_count = 0
odd_count = 0
for n in numbers:
    if n%2 == 0:
        even_count += 1
    else:
        odd_count += 1

print("Number of even numbers: ", even_count)
print("Number of odd numbers: ", odd_count)

or

even_num = len([n for n in numbers if n % 2 == 0])
odd_num = len([n for n in numbers if n % 2 != 0])

# Write a Python program that prints each item and its corresponding type from the following list
datalist = [1452, 11.23, 1+2j, True, 'w3resource', (0, -1), [5, 12], {"class":'V', "section":'A'}]
print(datalist)
for item in datalist:
    print(item, type(item))
    
# Write a Python program that prints all the numbers from 0 to 6 except 3 and 6
lst = []
for i in range(0,7):
    if i == 3 or i == 6:
        continue
    lst.append(i)
print(lst)

# Write a Python program to get the Fibonacci series between 0 to 50
x,y=0,1
while y<50: div="">
    print(y)
    x,y = y,x+y

#or
    
def fib(num):
    a,b = 0,1
    for num in range(num):
        if a < num:
            yield a
            a,b =b,a+b
print(list(fib(50)))

#  Write a Python program which takes two digits m (row) and n (column) as input and generates a two-dimensional array. The element value in the i-th row and j-th column of the array should be i*j
row_num = int(input("Input number of rows: "))
col_num = int(input("Input number of columns: "))
multi_list = [[0 for col in range(col_num)] for row in range(row_num)]

for row in range(row_num):
    for col in range(col_num):
        multi_list[row][col]= row*col

print(multi_list)

#or
        
row = 2
column = 3
a = [[i*j for j in range(column)] for i in range(row)]
print(a)

# Write a Python program that accepts a string and calculate the number of digits and letters
data = "Python 3.2"
d=l=0
for i in data:
    if i.isdigit():
        d += 1
    elif i.isalpha():
        l += 1
    else:
        pass
print("letters: ", l)
print("digits: ", d)

# Write a Python program to check whether an alphabet is a vowel or consonant
char = input("Input the letter of the alphabet: ")
if char in ('a','e','i','o','u'):
    print("%s is a vowel " % char)
else:
    print("%s is a consonant " % char)

## add key to dictionary
dict1 = {0:10, 1:20}
dict1[2] = "30"
print(dict1)

# Write a Python script to check if a given key already exists in a dictionary
dict={1:"one",2:"two",3:"three"}
print(dict)
print(dict.keys())
print(dict.values())

key = input("Enter the value of key ")
for k in dict:
    if k == key:
        print("Entered key %s is already there", key)
    else:
        print("Entered key is not present")

# Write a Python program to iterate over dictionaries using for loops
d = {"blue" : 1, "green" : 2, "yellow" : 3}
for key,value in d.items():
    print(key, value)

#Write a Python program to map two lists into a dictionary
keys = ['1','2','3','4','5','6']
values = ['one','two','three','four','five','six']
d = dict(zip(keys, values))
print(d)

# Write a Python function to find the Max of three numbers
def sum(n1,n2,n3):
    if n1>n2 and n1>n3:
        print("max number is", n1)
    elif n2>n1 and n2> n3:
        print("max number is", n2)
    else:
        print("max number is", n3)
sum(3,1,7)
        
# Write a Python function to sum all the numbers in a list
def sum(lst):
    res = 0
    for i in lst:
        res += i
    return res
    
lst = [1,2,3,4,5,-1]
print(sum(lst))

# Write a Python function to multiply all the numbers in a list
def mul(lst):
    res = 1
    for i in lst:
        res = res*i
    return res
lst = [8, 2, 3, -1, 7]
print(mul(lst))

#Write a Python program to reverse a string
def rev(str):
    res = str[::-1]
    return res

str = "1234abcd"
print(rev(str))

#Write a Python function to calculate the factorial of a number
def fac(n):
    if n <= 0:
        return 1
    else:
        res = n* fac(n-1)
        return res

print("factorial is :", fac(4))

# Write a Python function to check whether a number is in a given range
def test_range(n):
    if n in range(3,9):
        print("%s is in range"%n)
    else:
        print("number is outside of range")
test_range(5)

# Write a Python function that accepts a string and calculate the number of upper case letters and lower case letters
def string_test(s):
    d={"UPPER_CASE":0, "LOWER_CASE":0}
    for c in s:
        if c.isupper():
            d["UPPER_CASE"] += 1
        elif c.islower():
            d["LOWER_CASE"] += 1
        else:
            pass
    print("No of upper case chars: ", d["UPPER_CASE"])
    print("NO of lower case chars:", d["LOWER_CASE"])

string_test('The quick Brown Fox')

## Write a Python function that takes a list and returns a new list with unique elements of the first list
def unique_list(lst):
    x = []
    for a in lst:
        if a not in x:
            x.append(a)
    return x
   
lst = [1,2,3,3,4,4,5]
print(unique_list(lst))

or

def unique_list(lst):
    return list(set(lst))
 
lst = [1,2,3,3,4,4,5]
print(unique_list(lst))


    
# Write a Python program to print the even numbers from a given list
def print_even(l):
    even_list = []
    for i in l:
        if i % 2 == 0:
            even_list.append(i)
    return even_list
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(print_even(l))

or

def print_even(lst):
    evenlst = []
    for n in lst:
        if n % 2 == 0:
            evenlst.append(n)
    print(evenlst)
           
lst = [1,2,3,4,5,6,7,8]           
print_even(lst)


## Write a Python program that accepts a hyphen-separated sequence of words as input and prints the words in a hyphen-separated sequence after sorting them alphabetically
def input_str(s):
    lst = s.split('-')
    lst.sort()
    print('-'.join(lst))
    
input_str("green-red-yellow-black-white")

# Write a Python function to create and print a list where the values are square of numbers between 1 and 30 (both included)

def res(n1,n2):
        lst = list(range(n1, n2+1))
        res = map(lambda x: x*x, lst)
        return res
       
print(list(res(1,30)))

or

def sqr_num(n1,n2):
    res_list = []
    for i in range(n1,n2+1):
        res_list.append(i**2)
    return res_list

print(sqr_num(1,30))


# Write a Python program to access a function inside a function
def test(a):
    def add(b):
        nonlocal a
        a += 1
        return a+b
    return add
func = test(4)
print(func(4))

#Write a Python script to merge two Python dictionaries
d1 = {"a": "100", "b": "200"}
d2 = {"x": "4", "y": "500"}
d = d1.copy()
d.update(d2)
print(d)
print(d1.keys())
print(d1)
print(d1.values())

#Write a Python program to get the maximum and minimum value in a dictionary.
my_dict = {'x':500, 'y':5874, 'z': 560}
key_max = max(my_dict.keys(), key=(lambda k: my_dict[k]))
key_min = min(my_dict.keys(), key=(lambda k: my_dict[k]))

print('Maximum Value: ',my_dict[key_max])
print('Minimum Value: ',my_dict[key_min])

#or
values = my_dict.values()
print(values)
min = sorted(values)[0]
max = sorted(values)[-1]

print(min)
print(max)

# Write a Python program to multiply all the items in a dictionary
#import math
d = {'n1': 5,'n2': 2,'n3': 3}
#print(mul.dict.vlaues())
res = 1
for key in d:
    res= res*d[key]

print(res)

#or

d = {'n1': 5,'n2': 2,'n3': 3}
print(d.values())
res = 1
for i in d.values():
    res=res*i
print(res)
print(d.items())

# Write a Python program to check that a string contains only a certain set of characters (in this case a-z, A-Z and 0-9).
import re
def match(str):
    charRe = re.compile(r'[^a-zA-Z0-9.]')
    str = charRe.search(str)
    return not bool(str)

print(match("ABCDEFabcdef123450"))
print(match("*&%@#!}{"))

# Write a Python program that matches a string that has an a followed by zero or more b's 
import re
def text_match(text):
    patterns = 'ab*?'
    if re.search(patterns, text):
        return "match found"
    else:
        return "match not found"
print(text_match("ac"))
print(text_match("abc"))
print(text_match("abbc"))
print(text_match("bc"))
print(text_match("ababab"))

#for a followed by one or more b's
import re
def text_match(text):
        patterns = 'ab+?'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')

print(text_match("ab"))
print(text_match("abc"))

##Write a Python program that matches a string that has an a followed by zero or one 'b'.
import re  
def text_match(text):  
        patterns = 'ab??'  
        if re.search(patterns,  text):  
                return 'Found a match!'  
        else:  
                return('Not matched!')    
print(text_match("ab"))  
print(text_match("abc"))  
print(text_match("abbc"))  
print(text_match("aabbc"))
print(text_match("a"))

# Write a Python program that matches a string that has an a followed by three 'b' 
import re
def text_match(text):
        patterns = 'ab{3}?'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')

print(text_match("abbb"))
print(text_match("aabbbbbc"))

#Write a Python program that matches a string that has an a followed by two to three 'b' - 
import re  
def text_match(text):  
        patterns = 'ab{2,3}?'  
        if re.search(patterns,  text):  
                return 'Found a match!'  
        else:  
                return('Not matched!')  
  
print(text_match("ab"))  
print(text_match("aabbbbbc"))

# Write a Python program to find sequences of lowercase letters joined with a underscore 
import re  
def text_match(text):  
        patterns = '^[a-z]+_[a-z]+$'  
        if re.search(patterns,  text):  
                return 'Found a match!'  
        else:  
                return('Not matched!')  
  
print(text_match("aab_cbbbc"))  
print(text_match("aab_Abbbc"))  
print(text_match("Aaab_abbbc"))

# Write a Python program to find sequences of one upper case letter followed by lower case - 
import re  
def text_match(text):  
        patterns = '^[A-Z][a-z]+$'  
        if re.search(patterns,  text):  
                return 'Found a match!'  
        else:  
                return('Not matched!')  
  
print(text_match("bc"))  
print(text_match("Abbbc"))  
print(text_match("aabSBbbc"))

## Write a Python program that matches a string that has an 'a' followed by anything, ending in 'b' 
import re
def text_match(text):
        patterns = 'a.*?b$'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')

print(text_match("aabbbbd"))
print(text_match("aabAbbbc"))
print(text_match("accddbbjjjb"))

## Write a Python program that matches a word at the beginning of a string
import re  
def text_match(text):  
        patterns = '^\w+'  
        if re.search(patterns,  text):  
                return 'Found a match!'  
        else:  
                return('Not matched!')  
  
print(text_match("The quick brown fox jumps over the lazy dog."))  
print(text_match(" The quick brown fox jumps over the lazy dog."))

#Write a Python program that matches a word at end of string, with optional punctuation
import re  
def text_match(text):  
        patterns = '\w+\S*$'  
        if re.search(patterns,  text):  
                return 'Found a match!'  
        else:  
                return('Not matched!')  
  
print(text_match("The quick brown fox jumps over the lazy dog."))  
print(text_match("The quick brown fox jumps over the lazy dog. "))  
print(text_match("The quick brown fox jumps over the lazy dog "))

# Write a Python program that matches a word containing 'z'
import re  
def text_match(text):  
        patterns = '\w*z.\w*'  
        if re.search(patterns,  text):  
                return 'Found a match!'  
        else:  
                return('Not matched!')  
  
print(text_match("The quick brown fox jumps over the lazy dog."))  
print(text_match("Python Exercises."))

# Write a Python program that matches a word containing 'z', not start or end of the word. - 
patterns = '\Bz\B'

##Write a Python program to match a string that contains only upper and lowercase letters, numbers, and underscores 
import re
def text_match(text):
        patterns = '^[a-zA-Z0-9_]*$'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')

print(text_match("The quick brown fox jumps over the lazy dog."))
print(text_match("Python_Exercises_1"))

## Write a Python program where a string will start with a specific number
import re
def match_num(string):
    text = re.compile(r"^5")
    if text.match(string):
        return True
    else:
        return False
print(match_num('5-2345861'))
print(match_num('6-2345861'))

# Write a Python program to remove leading zeros from an IP address.
import re
ip = "216.08.094.196"
string = re.sub('\.[0]*', '.', ip)
print(string)

# Write a Python program to check for a number at the end of a string
import re  
def end_num(string):  
    text = re.compile(r".*[0-9]$")  
    if text.match(string):  
        return True  
    else:  
        return False    
print(end_num('abcdef'))  
print(end_num('abcdef6'))

# Write Python program to search the numbers (0-9) of length between 1 to 3 in a given string.
import re  
results = re.finditer(r"([0-9]{1,3})", "Exercises number 1, 12, 13, and 345 are important")  
print("Number of length 1 to 3")  
for n in results:  
     print(n.group(0))

# Write a Python program to find the substrings within a string
import re
text = 'Python exercises, PHP exercises, C# exercises'
pattern = 'exercises'
for match in re.findall(pattern, text):
    print('Found "%s"' % match)

# Write a Python program to find the occurrence and position of the substrings within a string
import re
text = 'Python exercises, PHP exercises, C# exercises'
pattern = 'exercises'
for match in re.finditer(pattern, text):
    s = match.start()
    e = match.end()
    print('Found "%s" at %d:%d' % (text[s:e], s, e))
     
# Write a Python program to replace whitespaces with an underscore and vice versa
import re
text = 'Python Exercises'
text =text.replace (" ", "_")
print(text)
text =text.replace ("_", " ")
print(text)

# Write a Python program to extract year, month and date from an url.
import re  
def extract_date(url):  
        return re.findall(r'/(\d{4})/(\d{1,2})/(\d{1,2})/', url)  
url1= "https://www.washingtonpost.com/news/football-insider/wp/2016/09/02/odell-beckhams-fame-rests-on-one-stupid-little-ball-josh-norman-tells-author/"  
print(extract_date(url1))

# Write a Python program to convert a date of yyyy-mm-dd format to dd-mm-yyyy format
import re
def change_date_format(dt):
        return re.sub(r'(\d{4})-(\d{1,2})-(\d{1,2})', '\3-\2-\1', dt)
dt1 = "2026-01-02"
print("Original date in YYY-MM-DD Format: ",dt1)
print("New date in DD-MM-YYYY Format: ",change_date_format(dt1))

# Write a Python program to match if two words from a list of words starting with letter 'P'.
import re
# Sample strings.
words = ["Python PHP", "Java JavaScript", "c c++"]

for w in words:
        m = re.match("(P\w+)\W(P\w+)", w)
        # Check for success
        if m:
            print(m.groups())

# Write a Python program to separate and print the numbers of a given string
import re
# Sample string.
text = "Ten 10, Twenty 20, Thirty 30"
result = re.split("\D+", text)
# Print results.
for element in result:
    print(element)

# Write a Python program to find all words starting with 'a' or 'e' in a given string
import re
# Input.
text = "The following example creates an ArrayList with a capacity of 50 elements. Four elements are then added to the ArrayList and the ArrayList is trimmed accordingly."
#find all the words starting with ‘a’ or ‘e’
list = re.findall("[ae]\w+", text)
# Print result.
print(list)

# Write a Python program to separate and print the numbers and their position of a given string.
import re
# Input.
text = "The following example creates an ArrayList with a capacity of 50 elements. Four elements are then added to the ArrayList and the ArrayList is trimmed accordingly."
for m in re.finditer("\d+", text):
    print(m.group(0))
    print("Index position:", m.start())

# Write a Python program to abbreviate 'Road' as 'Rd.' in a given string
import re
street = '21 Ramkrishna Road'
print(re.sub('Road$', 'Rd.', street))

# Write a Python program to replace all occurrences of space, comma, or dot with a colon - 
import re
text = 'Python Exercises, PHP exercises.'
print(re.sub("[ ,.]", ":", text))

#Write a Python program to find all five characters long word in a string
import re
text = 'The quick brown fox jumps over the lazy dog.'
print(re.findall(r"\b\w{5}\b", text))

#Write a Python program to find all three, four, five characters long words in a string.
import re
text = 'The quick brown fox jumps over the lazy dog.'
print(re.findall(r"\b\w{3,5}\b", text))

#Write a Python program to remove multiple spaces in a string
import re
text1 = 'Python      Exercises'
print("Original string:",text1)
print("Without extra spaces:",re.sub(' +',' ',text1))

#Write a Python program to remove all whitespaces from a string
import re
text1 = ' Python Exercises '
print("Original string:",text1)
print("Without extra spaces:",re.sub(r'\s+', '',text1))

# Write a Python program to implement pow(x, n).
class py_solution:
    def pow(self, x, n):
        if not n:
            return 1
        if n > 1:
            return eval("{}{}".format(x,"*{}".format(x)*(n-1)))
        if n < 1:
            return eval("1/({}{})".format(x, "*{}".format(x) * (-n - 1)))

print(py_solution().pow(2, -3));
print(py_solution().pow(3, 5));
print(py_solution().pow(100, 0));
            
# Write a Python class named Circle constructed by a radius and two methods which will compute the area and the perimeter of a circle
class Circle():
    def __init__(self,r):
        self.radius = r

    def area(self):
        return self.radius**2*3.14
    def perimeter(self):
        return 2*self.radius*3.14

NewCircle = Circle(8)
print(NewCircle.area())
print(NewCircle.perimeter())

#Write a Python program to remove duplicates from Dictionary
dict = {'one': 1, 'two': 2, 'three': 3, 'four': 1}
#print(dict)
#print(dict.items())
res = {}
for key,value in dict.items():
    if value not in res.values():
        res[key] = value
print(res)

## Write a Python program to check a dictionary is empty or not.
my_dict = {}
if not bool(my_dict):
    print("Dictionary is empty")
else:
    print("Dictionary is not empty")

##Write a Python program to combine two dictionary adding values for common keys
from collections import Counter
d1 = {'a': 100, 'b': 200, 'c':300}
d2 = {'a': 300, 'b': 200, 'd':400}
d = Counter(d1) + Counter(d2)
print(d)

#Write a Python program to print all unique values in a dictionary.
L = [{"V":"S001"}, {"V": "S002"}, {"VI": "S001"}, {"VI": "S005"}, {"VII":"S005"}, {"V":"S009"},{"VIII":"S007"}]
print("Original List: ",L)
u_value = set( val for dic in L for val in dic.values())
print("Unique Values: ",u_value)

#Write a Python program to sort a dictionary by key.
color_dict = {'red' : 1, 'blue': 2, 'orange': 3}
print(color_dict)
print(sorted(color_dict))
for key in sorted(color_dict):
    print("%s : %s" % (key, color_dict[key]))

#Write a Python program to sum all the items in a dictionary.
dict = {'n1': 1, 'n2': 2, 'n3': 3}
print(sum(dict.values()))



        




             













    
    
    
            
        

       
    
    

    

        
    


    
    


    



    


            

    

    















Thursday, April 27, 2017

Python Notes

Installation:

Install python 3.6.x
www.python.org
$ python   2.7x    -  idle
$ python3          -  idle3
NAWLEKHA-M-Q1GZ:python_training nawlekha$ idle3

IDE:-
------
idle    - default install
idlex   - extra features
pydev   - eclipse + python plugin
pycharm - is an IDE. PyCharm is cross-platform, with Windows, macOS and Linux versions

Python using "C"       - Cpython
python using "java"    - Jython
       using "C#"      - IronPython
       using c/cpython - stackless python
       using Cpython   - pypy

numpy      - data sci
matplotlib - graphs
pygame     - games
pybrain    - AI
sci-py     - machine learning
NLTK       - m/c learning
hadoop     - pyspark
WS         - AWS
web        - django/flask/bottle/cherrypy
Em         - rasberry-PI
IOT        - OS developed using python

=========================
>>Shell Scripts + awk + sed   - lack of data structures/libs

>>Perl                        - lack of read - regex/cpan.org - low level

>>TCL-TK                      - CLI - expect                  - low level

>>Python                      - app level program / SDN (software defined network)
                                pypi.python.org
                                simple
                                proc/oo/fp

>>Power SHell                 - windows
>> R                          - functional programming
>> Scala                      - functional programming
>> go scripts                 - threads - m/c dependency, used by google on server side

=========================
Python Arch

Object Oriented
>> every small component used in python is a OBJECT
Entities - world which exists
         - which can defined
         - which differ
Attributes -
Behaviours     -
Entities is divided into: (eg Employee) Array
Attributes - data on entity (Name, id, address, age) , (length, memory,name)
behaviour -  action on entity (createjob (), assignjob()), (add, insert,remove)

Data Structures:-
=================
a=10      a - object ref
          10- object
b=a       shallow copy - incr the ref count
c=10      data pool
a=63      it points another location
if a value change b value does't change. it points to another location

Im-Mutable  - int/long/float/str/tuple  # bool/complex/Nonetype/bytes
Mutable     - bytearray/list/set/dict   # frozenset

Basic INPUT statement in python:-
======================
a = input("string")
>>return value of input is a STRING

Basic OUTPUT statement in python:-
=======================
print("statement")
1) file extension should be .py
2) #! - she-bang
3) shld have execute perm
$ which python3

prog1.py:-
===========
#!/usr/bin/python3
a = input("Enter the value of a : ")
b = input("Enter the value of b : ")
res = a + b
print("Final ans = ",res)

prog2.py:-
===========
#!/usr/bin/python3
a = input("Enter the value of a : ")
b = input("Enter the value of b : ")

# type conversion
res = int(a) + int(b)
print("Final ans = ",res)

prog3.py:-
===========
#!/usr/bin/python3
a = int(input("Enter the value of a : "))
b = int(input("Enter the value of b : "))
res = a+b
print("Final ans = ",res)

string-class:-
==============
>>default is UNICODE strings
>>single quoted  a='hello'
>>double quoted  a="hello"
>>triple quoted  a='''hello'''

Convert the string from UNICODE to bytes
a="hello" # Str
res=a.encode("utf-8")   # converts unicode string to bytes
OR
a=b"Hello" # bytes
hardware representation is in bytes

a=b"hello"
res=a.decode("utf-8")    # convert bytes to UNICODE STRING

string operations:-
a='hello world'
string length          : len(a)
first element          : a[0]     # indexing
last element           : a[-1]
first 4 elems          : a[:4]    # slicing
last 4 elems           : a[-4:]
except first 4         : a[4:]
except last 4          : a[:-4]
except first 4 & last 4: a[4:-4]
Alt elem               : a[::2]
Alt elem               : a[1::2]
reverse                : a[::-1]
concate                : "hello" + a
upper                  : a.upper()

accept the string from the user

sampling
sa-MPLI-ng

1234567890
12-345678-90

res = input("Enter the string : ")
new = res[:2]+"-"+res[2:-2].upper()+"-"+res[-2:]
print(new)

accept the string from the user

sampling

S-nilpma-G

sol:
a[0].upper() + "-" + a[1:-1][::-1].lower() + "-" + a[-1].upper()

5/2   - true division
5//2  - floor division

Guess:-
========
a="12345678"

p1  = a[0:len(a)//2]

p2  = a[len(a)//2:]

print(p1)  # 1234
print(p2)  # 5678

others functions:-
-------------------
search for a substring in a string ---->  "hello" in mystr
                                   ---->  "hello" not in mystr
split the string                   -----> flst = a.split(delimiter)
a="192.168.1.125"

>> is "a" is string var - YES
>> what is delimiter    - "."
flst = a.split(".")
print(flst)
print(len(flst))
print(flst[0])
print(flst[-1])

find:-
------------
a.replace()
a.count()
a.index()
a.rindex()
a.find()
a.rfind()
a.rstrip()
a.lstrip()
a.strip()

----------------------------------------------------------------
a='sample data was added'

display the first word    a.split()[0]
display the last word     a.split()[-1]

display the first words last char  a.split()[0][-1]
display the last words first char  a.split()[-1][0]

a=10 20 30 40 50 60 70"
display first 4 fields

a.split()[0:4]

a="north 10,20,30,40"
display the first & last fields i.e 10 & 40

flst = a.split()[1].split(",")
print(flst[0],flst[-1])

import re
a="north 10,20,30,40"
flst = re.split("[\s,]",a)
OR
import re
a="sample-----hello-data----using-done"
b=re.sub("-+","-",a)
print(a)

a="north 10,20,30,40"

Branching:-
===========
>> and
>> or
>> not
>> elsif

if conidition:
  statement1
  statement2
else:
  statement1
  statement2

ex1:
 if a>=0 and a<=100:
   print("in range")
 else:
   print("out of range")

ex2:
 if a[0] in "aeiou":
   print("Vowel")
 else:
   print("Conso")

accept string & check the given string is a palindrome

madam
nitin
nayan
gadag

name = "nayan"
print(name[::])
print(name[::-1])
if name[::] == name[::-1]:
    print("palindrome")
else:
    print("no palindrome")

Generate natural nos:-
----------------------
>> what is the diff b/w range & xrange  of python 2.x
>> What is the diff b/w zip  & izip
>> GENERATOR pattern function - range(start,stop-1,step)
>> range(1,11)
>> list(range(1,1))

range will not allocate memory for all elements. It will assign memory based on demand.
range returns generator.generator has to be iterated then only we can extract the values

Loop:-
======
i=1
while i<=10:
 print(i)
 i+=1

Iterator:-
==========
>> special classes designed to work on CONTAINERs
>> automatically starts
>> automatically ends  - StopIteration
>> automatically advance

name='harish'

for alpha in name:
  print(alpha,end=" ")

Guess:-
--------
for i in range(1,6):
  print(i," = ",i*i)

Guess:-
=======
numlst = [10,20,30,40,50,60,70,80]

for i in range(len(numlst)):
  print(i,numlst[i])
OR
for num in numlst:
  print(num)

data is divided into
sequences = tuples, bytes, list
and
non-sequences = set and dict

=======================
Tuple-class:-
==============
>>constant collection
>>Im-mutable
>>months=("jan","feb","mar","apr".....)
>>weeks=()
>>numbers=("zero".....)

1) a = (10,20,30,40)
   OR
   a = 10,20,30,40

2) for num  in  a:
     print(num)

3) a,b,c = 10,20,30   # equal distribution - Tuple Unpacking

   a,b,*c = 10,20,30,40,50
   a,*b,c = 10,20,30,40,50
   *a,b,c = 10,20,30,40,50

Bytearray-class:-
=================
>>collection of bytes
>>collection of unsigned integers
>>mutable

a = bytearray([1,2,3,4])

=======================

List-class:-
=============
>> collection
>> Mutable

defined      - alst = [1,2,3,4,5]
length       - len(alst)

Add          - alst.append(60)
add more     - alst.extend([70,80,90])
insert       - alst.insert(index,value)

delete       - alst.pop(index)
delete       - alst.remove(VALUE)  # first occurance

sort         - a.sort()
reverse      - a.reverse()
stat fns     - sum(alst)
               max(alst)
               min(alst)

Guess:-
========
a = (10,20,[30,40,50],60,70)
a[0]
a[1]
a[2]
a[2][0] = 55
a[2].append(66)

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

oddlst = []  # compulsory
evenlst = []  #

for num in numlst:
   if num % 2 ==0:
     evenlst.append(num)
   else:
     oddlst.append(num)

grplst = ["team1-55",
          "team2-34",
          "team3-26",
          "team4-63",
          "team5-23"
         ]

#total vals
numlst=[]
for grp in grplst:
  flst = grp.split("-")
  numlst.append(int(flst[1]))

print(sum(numlst))

ex1:-
======
#outputlst = list(map(FUNCTNAME, inputlst))

datalst = ["10","20","30","40","50"]

templst=[]
for data in datalst:
  templst.append(int(data))
OR
for i in range(len(datalst)):
  datalst[i] = int(datalst[i])
OR
datalst = list(map(int, datalst))
print(sum(datalst))

https://public.etherpad-mozilla.org/p/python

studlst=[
         "arun-blr-CSE-15,20,18",
         "hari-chn-CIV-23,24,21",
         "tanu-hyd-MEC-18,19,11",
         "ravi-tvm-ECE-11,19,20"
       ]
avg of best 2

sol:
for stud in studlst:
  name,loc,dept,*mlst = stud.replace("-",",").split(",")
  mlst=list(map(int,mlst))
  mlst.sort(reverse=True)
  avg=(mlst[0] + mlst[1])/2
  print(name,loc,dept,avg)

team1= ["anil","ravi","guru","jagu","john"]
team2= ["john","anil","hari","amith","jaya"]
for mem in team1:
  if mem in team2:
    print(mem)

set-class:-
===========
>> collection of unique values
>> duplicates are deleted
>> non-sequence data structure
>> un ordered datastructure

define    :  a={10,20,30,40,50}
             b={10,40,80,20,70}

union     :  a|b   # a.union(b) : {70, 40, 10, 80, 50, 20, 30}
intersect :  a&b   # a.intersection(b)  : {40, 10, 20}
minus     :  a-b   # a.minus(b) : {50, 30}

common b/w two sets   : a&b
uncommon b/w two sets : (a|b) - a&b
                      : (a-b) | (b-a)

dict-class:-
============
>> collection of key-value
>> mutable
>> lookup table
>> non-sequence / un ordered data structure
>> key-based lookup
define      : colors={
                      "blue" : [10,20,30],
                      "red"  : [40,50,60],
                      "green": [70,80,90]
                     }
get         : colors["red"]
            : colors.get("red","UNKNOWN COLOR")
set         : colors["red"]=[11,22,33]
add         : colors["white"] = [5,6,7]
            : colors.update({"white" : [5,6,7]})
search      : if "black" in colors
delete      : colors.pop("red")
ALL KEYS    : colors.keys()
ALL VALS    : colors.values()
traverse    : for i in colors:
                 print(i,colors[i])
-------------------------------------------------
colors={
        "blue" : [10,20,30],
        "red"  : [40,50,60],
        "green": [70,80,90]
    }

user = input("Enter any color : ").lower()

if user in colors:
    print("yes")
    print("Selected color = ",user)
    print("Value          = ",colors[user])
else:
    print("no")
    print(colors.keys())



studs = {"arun"  : "blr-cse-VIT",
         "john"  : "chn-ece-BIT",
         ..
        }
prompt the user to enter the name
         name
         loc
         dept
         coll name


emps={ 101  :  "arun-blr-500",
       102  :  "jack-chn-503",
       103  :  "ravi-hyd-501",
       104  :  "tina-tvm-500"
     }
depts={500 : "sales",
       501 : "purch",
       502 : "accts",
       503 : "hrd"
      }

emp-id : 101

name     =
loc      =
deptid   =
deptname =

code = int(input("Enter the emp code : "))

if code in emps:
  name,loc,deptid = emps[code].split("-")
  print("NAme = ",name)
  print("loc  = ",loc)
  print("Depid = ",deptid)
  print("dname = ",depts[int(deptid)])
else:
  print("Not Found")

===========================

a=10          #int
b="hello"     #str
c=2.5         #float
e=bytearray() #bytearray
f=(1,2,3)     #tuple
g=[1,2,3]     #list
h={1,2,3}     #set
i={}          #dict
j=b"sample"   #bytes
k=None        # empty

==========================
Composition:-
==============
a = [
      [1,2,3],
      [4,5,6],
      [7,8,9]
    ]
type(a)

print(a[0][0])
1

How to install a 3rd party modules in Python:-
==============================================
$ sudo pip3 install numpy
OR
$ sudo easy_install3 numpy
pip3 install pandas
pip3 install matplotlib

numpy:-
=======
>> written in "C" - cython
>> fast to python

import numpy as np

a = np.array([[1,2,3],[4,5,6],[7,8,9]])
b = np.array([[1,2,3],[4,5,6],[7,8,9]])

c1=a+b

c2=a.dot(b)

print(c1)
print(c2)

print(a[:,0])
print(a.sum())

print(np.arange(1.0,2.0,.1))
----------------------------------------------------------------------------
studs= {"arun" : [1,2,3],
        "ravi" : [4,5,6]
       }

studs["arun"]
studs["arun"][0]
studs = {
          "arun" : {"dept" : "CSE", "marks" : [1,2,3]  },
          "ravi" : {"dept" : "ECE", "marks" : [4,5,6]  }
        }

studs["ravi"]["dept"]
studs["arun"]["marks"][0]

HTML - XML/JSON
JSON -
Perl -
Ruby -
======================
Files :-
========
>> to store the data permanently

>> Text Files   - human readable
>> Binary Files - m/c readable

>> 3 ref points   BOF - 0
                  CUR - 1
                  EOF - 2

>> Diff modes
    r - rb  - readonly     - BOF - retained
    w - wb  - writeonly    - BOF - lost
    a - ab  - appendonly   - EOF - retained
    r+ - rb+ - read-write  - BOF - retained
    w+ - wb+ - write-read  - BOF - lost
    a+ - ab+ - append-read - EOF - retained

>> Random Access

   filehandler.seek(No_of_bytes, REF_POINT)

   filehandler.tell() - return nos bytes advanced from BOF to CURR Loc

fob.seek(0,0)    # to move to BOF
fob.seek(25,0)   # from BOF move 25 bytes ahead
fob.seek(100,1)  # from CURR loc move 100 bytes ahead
fob.seek(0,2)    # move to EOF

f1 = open("one.txt","w")

f1.write("Hello world\n")
f1.write("sample data was added\n")
f1.write("Thatz the end")

f1.close()

f2 = open("one.txt","r")
for line in f2:
  print(line)

f2.close()
--------------------------------------------------------------
fob = open("data.txt","w+")

fob.write("kar-blr\n")
fob.write("ap-ama\n")
fob.write("ts-hyd\n")
fob.write("tn-chn\n")
fob.write("ker-tvm")

fob.seek(0,0)
for line in fob:
  line=line.strip()
  print(line.split("-")[0])

fob.close()
--------------------------------------------------------------
fob = open("data.txt","w+")
fob.write("arun-maths-10-sci-20-soc-30\n")
fob.write("arun-maths-10-sci-20-soc-30\n")
fob.write("arun-maths-10-sci-20-soc-30\n")
fob.write("arun-maths-10-sci-20-soc-30\n")
fob.write("arun-maths-10-sci-20-soc-30)

csvfile = open("out.csv","w")

fob.seek(0,0)

for line in fob:
  line = line.strip()
  if line:
    flst = line.split("-")
    tot  = sum(map(int,flst[2::2]))
    print("%s,%.2f\n" %(flst[0],tot))
    csvfile.write("%s,%.2f\n" %(flst[0],tot))
fob.close()
csvfile.close()

----------------------------------------------------------------
strbuffer = fob.read()    # read complete file as string
strbuffer = fob.read(50)  # read only 50 bytes
strbuffer = fob.readline()  # read upto \n or EOF
lstbuffer = fob.readlines() # read complete file
fob.write(strbuffer)
fob.writelines(lstbuffer)
-----------------------------------------------------------------
studs.csv
----------
name,dept,avg
arun,CSE,80
ravi,ECE,85
john,ELE,78
hari,CSE,67

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("studs.csv")

print(df)

df.plot()

plt.show()
------------------------------------------------------------------------------

import os
import sys

if not os.path.isfile("one.txt"):  #check whether file exists
  print("File not found")
  sys.exit()
------------------------------------------------------------------------------
with open("one.txt","r") as fob:  # file autoclosed
  print("hello")
  print("hai")

print("Some")
------------------------------------------------------------------------------
xlrd - excel reader
xlwt - excel writer

ex:

import xlrd

b = xlrd.open_workbook("hello.xlsx")

sheet = b.sheet_by_index(0)

for i in range(sheet.nrows):
 for j in range(sheet.ncols):
  print(sheet.cell(i,j).value)

numpy           OR   custom built Framework  or PYATS
pandas
matplotlib
xlrd
xlwt
--------------------------------------------------
Functions:-
===========
f(x) = x2
f(5) = 25
def f(x):
  return x*x
OR
f1 = lambda x : x*x
>>> f1(5)
25

ex:
f(x,y) = x+y
f = lambda x,y :  x+y
>>> f(2,3)
5
def fun(x,y):
  return x+y

>> var defined within the fn - LOCAL
>> var defined outside the fn - GLOBAL
>> fns has to be defined before its call

def add(n1,n2):
  res = n1 + n2
  retunr res

a=10
b=20
c = add(a,b)
print(c)

--------------------------------------------------------
namelst = ["arun","ravi","john","manu","eshu"]
reslst=[]
for name in namelst:
  reslst.append(name[0])
OR
reslst = [name[0] for name in namelst  ]   # list comprehension
OR
reslst = list(map(lambda x : x[0], namelst))  # map-iterator
--------------------------------------------------------
numlst = [1,2,3,4,5,6,7,8]
reslst=list(map(lambda x: x*x , numlst))
zonelst=['north-10','south-20','east-30','west-40']
numlst = list(map(lambda x: int(x.split("-")[1]), zonelst))
print(sum(numlst))
--------------------------------------------------------
# proof the that all the cALL in python are CALL BY REFERENCE
def add(n1,n2):
 print("n1 = ",id(n1))
 print("n2 = ",id(n2))
 res = n1 + n2
 return res

a=10
b=20
print("a = ",id(a))
print("b = ",id(b))
c = add(a,b)
print(c)

--------------------------------------------------------
Guess:-
========
def fun(alst):
  alst[0:4] = "0" * 4
  print("ALST = ",alst)
numlst = [10,20,30,40,50]
fun(numlst)
print("NUMLST = ",numlst)

------------------------------------------------------------------------
positional args:-
=================
def addRecord(name,dept,loc,sal):
  pass

addRecord()                       # error
addRecord("arun")                 # Error
addRecord("arun","sales")         # error
addRecord("arun","sales","blr")   # error
addRecord("arun","sales","blr",15000)  # right-way
addRecord("sales","blr","arun",15000)  # right-way  # programmers

default args:-
==============
def addRecord(name=None,dept="finan",loc="hyd",sal=0):
  pass

addRecord()                       # work
addRecord("arun")                 # works
addRecord("arun","sales")         # works
addRecord("arun","sales","blr")   # works

addRecord("arun","sales","blr",15000)  # works
addRecord("sales","blr","arun",15000)  # works  # programmers resp
                                                # to pass in correct order
keyword args:-
==============
def addRecord(name=None,dept="finan",loc="hyd",sal=0):
  pass

addRecord(loc="chn")
addRecord(loc="blr",dept="IMS")


variable args:-
===============
>> *args
>> args is a TUPLE

def fun(*args):
  print(args)

fun()
fun(10)
fun(10,20,30,40)
fun(10,20)
fun(10,20,30)


variable keyword args:-
=======================
>> **kwargs
>> dictionary

def fun(**kwargs):
  print(kwargs)

fun(a=10,b=20,c=30)
fun()
fun(old="new.txt", new="that.txt")

Guess:-
---------
def fun(*args,**kwargs):
  pass

>> non-keyword first and then keyword args

others:-
--------
>>global
>>globals()
>>locals()

example for special fn - globals()
def fun():
  num=55  # LOCAL
  print("FUN = ",num)
  print("GLOBL = ",globals()["num"])

num=10    # GLOBAL
print("MAIN = ",num)
fun()
print("MAIN = ",num)

ex: for keyword global

def fun():
  global num
  num=55  # LOCAL
  print("FUN = ",num)

num=10    # GLOBAL
print("MAIN = ",num)
fun()
print("MAIN = ",num)

===============================
Modules:-
=========
>> collection of fns/classes
>> file extension shd be .py
>> can be include   import modulename
                    from modulename/package import *
>> once a module is import - BYTE CODE .pyc
>> module search path  import sys
                       sys.path

mathlib.py   - open source
mathlib.pyc  - closed source
mathlib.exe  - standalone / non-portable - py2exe

packages:-
==========
>> is a FOLDER
>> collection of modules/subpackages
>> every pack shld have a compulsory file - __init__.py
               
                            mylibs
                              |
     -------------------------------------------------------------------
    |                                                   |                                   |
mathlib.py another.py __init__.py
---------- ----------              -------------
def add(a,b): def add():              __all__=['mathlib',
  print("PACk = ",__package__)      print("HEllo")                 'another']
  print("SYM  = ",__name__)
  print("ANS = ",a+b)

def minus(a,b):
  print(a-b)

def divide(a,b):
  print(a/b)

def mult(a,b):
  print(a*b)

sample1.py:-
===========
import mylibs.mathlib
mylib.mathlibs.add(10,20)

sample2.py:-
============
from mylibs import *    # __init__.py
mathlib.add(10,20)
another.add()

sample3.py:-
============
from mylibs.mathlib import *
add(10,20)

=============================
mathlib.py
----------
add()/minus()/divide()/mult()

Method1:- Method2:
========= =========
import mathlib import mathlib as m

mathlib.add() m.add()

Method3:- method4:-
========== ==========
from mathlib import add from mathlib import *
add() add()

Method5:-
==========
from mathlib import add as libadd
def add():
  print("HELLO WORLD")

add()
libadd()

===========================
using import - call f1/f2/f3

import vendors.intel
import vendors.sony
import vendors.subvendor.nokia

vendors.intel.f1()
vendors.sony.f2()
vendors.subvendor.nokia.f3()

===========================
using from - call f1/f2/f3
from vendors import *
intel.f1()
sony.f2()
subvendors.nokia.f3()

===============================
from vendors.subvendors.nokia import *
f3()

===============================
import modulename - fully qualified names
from package import * - relative names
from package.module import * - relavtive name

===============================
classes:-
=========

>> local var - private will be accessible only within class
   global var - public will be accessible in/outside class


>> special fns
   constructor - fn same name as the CLASSNAME
                 is automatically called when a OBJECT IS CREATED

   destructor  - fn same name as the ~CLASSNAME
                 is automatically called when a OBJECT goes out of scope


>> Compile Time Class Development   - C++/JAVA/C#

>> Run Time Class Development       - PERL/PYTHON


Python Class Development:-
==========================
>> Run Time Classes - Monkey patching - Metaclasses
>> Class heirarchy - base class for all the classes - "object"
>> OLd class style  - python 2.x
>> New class style  - python 2.x / python 3.x
>> this pointer is renamed as "self"
>> self pointer is a compulsory arg for all the MEMBER FNS - RUN TIME CLASSES
>> constructor is def __init__
>> destructor is  def __del__  # optional - garbage collector
>> default access specifier within class - PUBLIC

mylib.py:-
==========
class Circle:

   def __init__(self,a):
      self.radius = a
      self.area = 0

   def find(self):
      self.area = 3.14 * (self.radius**2)

   def show(self):
      print(" %.2f = %.2f " %(self.radius,self.area))

sample.py:-
===========
import mylib
c1 = mylib.Circle(2.5)
c1.find()
c1.show()

=============================
class student:
 def __init__(self,name,mlst):
  self.name = name
  self.mlst = mlst

 def find(self):
  self.avg = sum(self.mlst)/3

 def show(self):
  print("%s %s %s"  %(self.name,self.mlst,self.avg)

 def compare(self,other):
  if self.avg > other.avg:
    return True
  else:
    return False


from mylib import student

s1 = student("Arun",[10,20,30])
s2 = student("RAvi",[40,30,10])

s1.find()
s2.find()

if s1.compareAvg(s2):
  s1.show()
else:
  s2.show()

Magic Methods:-
===============

>> Operator overloading

+    def __add__(self,other)
-    def __sub__(self,other)
*    def __mul__(self,other)
/    def __div__(self,other)

==   def __eq__(self,other)
!=   def __ne__(self,other)
>    def __gt__(self,other)
>=   def __ge__(self,other)
<    def __lt__(self,other)
<=   def __le__(self,other)

---------------------------------------------------------------------------
how to write a class         - keyword class
object im memory             - dictionary
this pointers                - self   # is not a keyword
acess data members in class  - self.datamember
acess data mem out class     - object.datamember
access methods               - object.methodname(args)
ctor                         - def __init__()
dtor                         - def __del__()
private data members         - self.__datamember
semi private                 - self._datamember
public data members          - self.datamember
private method               - def __method(self):
operator overloading         - magicmethods def __eq__(self,other)

static data members          - class properties
                               classname.staticdatamembers
static methods               - @staticmethod
inheritance                  - ISA-relationship
method over-riding           - super().methodname()
                               OR
                               classname.METHODNAME(self)

see later:-
----------
import abc

---------------------------------------------------------------------------
ex of static data members:-
===========================

a=10

class Sample:
  total
  def __init__(self,val):
    b=20
    self.value = val

what is a ? - GLOBAL VARIABLE print(a)
what is b ? - LOCAL VAR  print(b)
what is self.value ? - data member print(self.value)
what is total      ? - STATIC DATA MEMBER print(Sample.total)


ex:
class stock(object):  new style classes in python 2.x
class stock:          old style classes in python 2.x

class stock:          only style in python 3.x

ex:
class stock:

   __total=0
   def __init__(self,name,cat,qty):
     self.name = name
     self.cat  = cat
     self.qty  = qty
     stock.__total = stock.__total + self.qty

   @staticmethod           # inbuilt decorator
   def showtotal():
     print("Total = ",stock.__total)


if __name__ == '__main__':
 stock.showtotal()
 s1 = stock("a","b",10)
 s2 = stock("a","b",10)
 s3 = stock("a","b",10)
 s4 = stock("a","b",10)
 stock.showtotal()

---------------------------------------------------------------
example for Inheritance:-
=========================
>> there is CTOR CASCADING in python, which we have to do

class Account:
  def __init__(self,num,name=None,bal=0):
    self.num = num
    self.name = name
    self.bal  = bal
  def show(self):
    print("%s %s %s" %(self.num,self.name,self.bal))

class Savings(Account):                  # ***** Deriving class
  def __init__(self,num,name=None,bal=0,intrate=4,cap=0):
    Account.__init__(self,num,name,bal)  # **** CTOR CASCADING
    self.intrate = intrate
    self.cap     = cap
  def show1(self):
    print("%s %s" %(self.intrate,self.cap))


s1 = Savings(12345,"arun",15000,5.5,100000)
s1.show()
s1.show1()

---------------------------------------------------------------
example for method over-riding:-
================================
class Account:
  def __init__(self,num,name=None,bal=0):
    self.num = num
    self.name = name
    self.bal  = bal
  def show(self):
    print("%s %s %s" %(self.num,self.name,self.bal))

class Savings(Account):                  # ***** Deriving class
  def __init__(self,num,name=None,bal=0,intrate=4,cap=0):
    Account.__init__(self,num,name,bal)  # **** CTOR CASCADING
    self.intrate = intrate
    self.cap     = cap
  def show(self):                      # over ridden method
    super().show()                     # how to invoke a OVER RIDDEN METHOD
    print("%s %s" %(self.intrate,self.cap))


s1 = Savings(12345,"arun",15000,5.5,100000)
s1.show()

---------------------------------------------------------
Exception handling:-
====================
>> Software interrupts in a program - Exception

>> Implicit handlers
     done by the compilers it self
     abrupt exit
     there is no communication to the programmers


>> Explicit handlers
     designed by programmers
     safe exit
     program resumes back to the SAID POINT
     keywords try/except/finally/raise

>> asynch exceptions - automatic
>> synch exceptions  - mannual  - raise

ex:
# user defined exceptions
class ZeroError(Exception):
  def __init__(self,mesg):
    Exception.__init__(self,mesg)

n1 = input("Enter the value of n1 : ")
n2 = input("Enter the value of n2 : ")

n1 = int(n1)
n2 = int(n2)

if n1==0 or n2==0:
  raise ZeroError("Value cannot be ZERO")

res = n1 + n2
print("FINAL = ",res)

ex:
class ZeroError(Exception):
  def __init__(self,mesg):
    Exception.__init__(self,mesg)

try:
    n1 = input("Enter the value of n1 : ")
    n2 = input("Enter the value of n2 : ")
    n1 = int(n1)
    n2 = int(n2)

    if n1==0 or n2==0:
       raise ZeroError("Value cannot be ZERO")
    res = n1 + n2
    print("FINAL = ",res)
except:
    print("Oh problem")

ex:
import traceback

class ZeroError(Exception):
  def __init__(self,mesg):
    Exception.__init__(self,mesg)

try:
    n1 = input("Enter the value of n1 : ")
    n2 = input("Enter the value of n2 : ")
    n1 = int(n1)
    n2 = int(n2)

    if n1==0 or n2==0:
       raise ZeroError("Value cannot be ZERO")
    res = n1 + n2
    print("FINAL = ",res)
except ZeroError as e1:
  print("Action-1",e1)
except ValueError as e2:
  print("Action-2",e2)
except EOFError as e3:
  print("ACtion-3",e3)
except:                            # Generic CATCH BLOCK
    print("Oh problem")
    traceback.print_exc()
finally:
    print("Cleanup")

==============================
Inbuilt libs:-
==============
CORE LIBs - which are installed with the compiler

1) Data persistance modules

pickle   - import pickle
json     - imprt json

shelve   - import shelve
db       - import sqlite3

import pickle

fob = open("info.pickle","wb")

info = { "A" : 10,
         "B" : "hello",
         "C" : 2.5
         "D" : [10,20,30,40],
         "E" : (1,2,3)
         "F" : {"a":1,"b":2}
       }
pickle.dump(info, fob)
fob.close()
------------------------------------------------------------------------
import pickle

fob = open("info.pickle","rb")

res = pickle.load(fob)

fob.close()

print(res)

--------------------------------------------------------------------

2) File Related

import glob        - list all the files
import fileinput   - read the file
import filecmp     - compare 2 files/2 dirs
import shutil      - copy/move file/dirs
import tarfile     - compress folder
import zipfile     - compress file
import stat        - file stats
ex:
import glob
res = glob.glob("*.txt")
print(res)

ex:
import fileinput
res = fileinput.input("one.txt")
print(list(res))

3) Date & Time

from datetime import date,timedelta

print(date.today())

d1 = date(2010,5,1)
d2 = date.today()

print(d2-d1)
print(d1==d2)
print(d2+timedelta(15))


from datetime import time
from datetime import datetime

4) Others

import math
import random
import hashlib   - md5/sha1/sha256
import optparse/argparse/shopts
import logging

import os
import sys
ex:
from optparse import OptionParser

p = OptionParser()
p.add_option("--host1",type="str",action="store",dest="a")
p.add_option("--host2",type="str",action="store",dest="b")
p.add_option("--out",type="int",action="store",dest="c")
p.add_option("--in",type="int",action="store",dest="d")

args, extraargs = p.parse_args()

print(args.a)
print(args.b)
print(args.c)
print(args.d)

=============================

debug   - 10
info    - 20
warning - 30  - default level
error   - 40
critical- 50


import logging

logging.debug("Hello-1")

logging.info("Hello-2")

logging.warning("Hello-3")

logging.error("Hello-4")

logging.crtical("Hello-5")

ex:

import logging
logging.basicConfig(level=logging.DEBUG)

logging.debug("Hello-1")

logging.info("Hello-2")

logging.warning("Hello-3")

logging.error("Hello-4")

logging.critical("Hello-5")

============================
import sys   -  Interface b/w programmer & Python Inter

sys.version
sys.implementation
sys.path

sys.argv
sys.stdin
sys.stdout
sys.stderr

sys.platform
sys.getsizeof(a)
sys.getrefcount(a)


import os    - Interface b/w programmer & underlying OS

os.name
os.pid()
os.getcwd()
os.system("commands")  #    os.system("echo $$")
os.remove("one.txt")
os.environ
os.environ["PATH"]

Concurrency:-
=============

import time
import os

def job1():
  print("REAding from file",os.getpid())
  time.sleep(4)

def job2():
  print("Writing from file",os.getpid())
  time.sleep(6)

def job3():
  print("copying files", os.getpid())
  time.sleep(7)

def job4():
  print("printing to PRN", os.getpid())
  time.sleep(5)

if __name__ == '__main__':
  start = time.time()
  job1()
  job2()
  job3()
  job4()
  end = time.time()


import multiprocessing
import threading
import subprocess
import concurrent


ex:
import time
import os
from multiprocessing import Process
from threading import Thread


def job1():
  print("REAding from file",os.getpid())
  time.sleep(4)

def job2():
  print("Writing from file",os.getpid())
  time.sleep(6)

def job3():
  print("copying files", os.getpid())
  time.sleep(7)

def job4():
  print("printing to PRN", os.getpid())
  time.sleep(5)

if __name__ == '__main__':
  p1 = Process(target=job1,args=())
  p2 = Process(target=job2,args=())
  p3 = Process(target=job3,args=())
  p4 = Process(target=job4,args=())

  p1.start()
  p2.start()
  p3.start()
  p4.start()
  start = time.time()
  p1.join()
  p2.join()
  p3.join()
  p4.join()

  end = time.time()
  print("Time took = ",end-start)


ex:-
====

import time
import os
from multiprocessing import Process
from threading import Thread


def job1():
  print("REAding from file",os.getpid())
  time.sleep(4)

def job2():
  print("Writing from file",os.getpid())
  time.sleep(6)

def job3():
  print("copying files", os.getpid())
  time.sleep(7)

def job4():
  print("printing to PRN", os.getpid())
  time.sleep(5)

if __name__ == '__main__':
  p1 = Thread(target=job1,args=())
  p2 = Thread(target=job2,args=())
  p3 = Thread(target=job3,args=())
  p4 = Thread(target=job4,args=())

  p1.start()
  p2.start()
  p3.start()
  p4.start()
  start = time.time()
  p1.join()
  p2.join()
  p3.join()
  p4.join()

  end = time.time()

  print("Time took = ",end-start)

Queue
Lock
Semaphores

t = threading.Lock()
t.acquire()

act

t.release()
==========================

Test     - pyUnit / unittest - WBT


import unittest
import yourlibtotest

class mytest(unittest.TestCase):

  def setUp(self):
    pass

  def tearDown(self):
    pass

  def test1(self):
    self.assertEquals(yourlibtotest.funct(10,20) , 0)


if __name__ == '__main__':
  unittest.main()


Doc     :   def fun():
             ''' doc
             some
             some
             '''
             source code


Install

Distribute   - distutils / setuptools

setupy.py
==========
from distutils.core import setup
setup(name='foo',
      version='1.0',
      py_modules=['file1',file2,file3,file4],
      )


$ python setup.py sdist

$ foo.tar.gz
=========================

$ extract tar file

$ Cd foo

$ python setup.py install
========================

debug
automation  - CLI/Net/Web