# I M O R T re import re text="""kDD=Dello aWd dz 44 ,6.1 25.0100# @. %,9@# Ha HaHaa 1-800-700-3000 , Mrs. Smith ,cat bat sat Mr Rahet ,Mrs Rahet ,Miss Rahet""" pattern=re.compile (r"(Mr|Mrs|Ms)\.?\s[A-Z]\w*") matches =pattern.finditer(text) # find string plus location in text for match in matches: print(match) pattern=re.compile (r"M(r|s|rs)\.?\s[A-Z]\w*") matches =pattern.finditer(text) # find string plus location in text for match in matches: print(match) pattern=re.compile (r"avb") matches =pattern.finditer(text) # find string plus location in text for match in matches: print(match) a=re.findall("\d*\.?4\d+",text) # find particular character 0 or 1 print(a) pattern=re.compile (r"[89]00[-.]\d\d\d[-.]\d\d\d\d") # either 8 or 9 matches =pattern.finditer(text) # find string plus location in text for match in matches: print(match) pattern=re.compile (r"[^a-zA-Z0-9]") #negate character in bracket pattern=re.compile (r"[^b]at") # ^ is negate character in bracket matches =pattern.finditer(text) # find string plus location in text for match in matches: print(match) #print(a) a=re.findall("\.?4",text) # read 0 or 1 character print(a) v=re.match(pattern="[a-z]",string=text) print(v)# match string plus location in text a=re.findall("[a-z]",text) # small letter print(a) a=re.findall("[A-Z]",text) # capital letter print(a) a=re.findall("\d+",text) # digits plus only print(a) a=re.findall("\D",text) # no digits print(a) a=re.findall("\b",text) # space and word boundry print(a) a=re.findall("\B",text) # exclude space word boundry print(a) a=re.findall(".$",text) # find last character in string print(a) a=re.findall("^.",text) # find starting character in string print(a) a=re.findall("\w*",text)# letter and digit exclude special character print(a) a=re.findall("\W+",text)# special character print(a) a=re.findall("\d*\.?\d+",text) #all digit with decimal ???? print(a) a=re.findall("a....",text) # per dot per character twice print(a) #carret symbol for start with the string a=re.findall("^D",text) # confirm starting letter in string print(a) #$ confirm for end with that string a=re.findall(".?$",text) print(a) # 0 or more occourance use with dot until i 2 occourance a=re.findall("=.*i",text) print(a) # + is for one or more occourance,use with dot full iine after d a=re.findall("d.+",text) print(a) #zero or one occurance dot use 2 occorance a=re.findall("a....",text) print(a) #{}for pulling data, use with dot, 9 character after DD a=re.findall("DD.{8}",text) print(a) a=re.findall ("[^a-f]",text) # it hide these character a to f and split print(a) # either | one {} data will be pulled out a=re.findall("DD.{}|DD.{6}",text) print(a) # split with spaces ??????????????? a=re.split(pattern =" ",string=text) print(a) # a= re.split(pattern="\s",string=text) # spaces plus new line print(a) a= re.split(pattern="\S",string=text) # no spaces & new line print(a) #pattern= r"abc"#????????????????????????????? v=re.match(pattern="[a-z]",string=text) print(v) pattern = r"E" if re.match(pattern,"eggspamsegausagespamegg"): print("match is ok") else: print("no match") if re.search(pattern,"eggspamsausagespamE"): print("search is ok") else: print("no search found") x=re.findall(pattern,"eggspamsausagespamE") print(x) # Use \S to match everything othe than ??????? a=re.findall(pattern ="\S", string =text) print(a) # Use re.Sub() to find and replace substitutins new_lines=re.sub (pattern="[0-9]+",repl="770",string=text,count=1) print(new_lines) # strip punctuation character only new_line=re.sub (pattern="[^\w\s]",repl=" ",string =text) print(new_line) # strip punctuation and spaces ???? new_line=re.sub(pattern="\W",repl="",string=text) print(new_line) # digits are replaced s=re.sub(pattern=r"[0-9]",repl="80",string=text) print(s) # it save abcdef other are removed with span=re.sub(pattern="[^a-f]",repl=" ", string=text) print(n) #pattern= r"abc"#??? v=re.match(pattern="[a-z]",string=text) print(v) # removes special character new_line=re.sub (pattern="[^\w\s]",repl=" ",string=text) print(new_line) import re pattern = r"[A-Z][A-Z-a-z][d-z-0-8]" if re.search(pattern, "LS8"): print("Match 1") if re.search(pattern, "EE3"): print("Match 2") if re.search(pattern, "Aa8"): print("Match 3") import re Id="AA45" if re.search("[A-Z][A-Z][0-9][0-7]$",Id): print("Searching") else: print("Wrong format") # C L A S S class Fruits: def __init__ (self,name,nam): self.name="Banana" self.nam="Orange" @property # @property work as getter method def show(self): print(f'{self.name} {self.nam} was accessed') return self.name,self.nam @show.setter def set_word(self,value): print(f'{self.name} {self.nam} is now changed to {value}') self.name=value self.nam=value @set_word.deleter def delet_word(self): print(f'{self.name} is now deleted.') if __name__ == "__main__": fruit=Fruits(" "," ") fruit.show fruit.set_word="Mabgo & Raspberry" del fruit.delet_word class EXAMPLE_1: attr_1="ggg" # class attribute attr_2="UUU" # class attribute def __init__(self,a,b): self.a=1000 self.b=2000 self.c=3000 #?????? @property # work as initial setter def GO_SET(self): print(f'{self.a}, {self.b}, {self.c} is SET.') #return self.a+self.b @GO_SET.setter # work as re setting to SET file def RE_SET(self,value): print(f'{self.a} ,{self.b} ,{self.c} is changed to {value}') self.a=value self.b=value self.c=value @RE_SET.deleter def DELEAT_FILE(self): print(f'{self.a} was deleted') @staticmethod # not reachable from instance def STATIC(): print("this is static ") @classmethod # work as per main class method def CLASS_METHOD(cls): return aa*bb aa=12 bb=12 a=4 b=4 obj=EXAMPLE_1(" "," ") obj.GO_SET obj.RE_SET="jingo, bingo,tingo" obj.RE_SET # confirm changed value obj.GO_SET # confirm again value is changed print (EXAMPLE_1.attr_1) print(obj.STATIC ()) # is readable print(EXAMPLE_1.STATIC ()) # is readable print(EXAMPLE_1.attr_2) print(obj.CLASS_METHOD()) del obj.DELEAT_FILE class Person:#Appficial def __init__(self): self.name="turab" self.age= 70 self.weight=220 def print_person(self): print(f'Name:{self.name}') print(f'Age:{self.age}') print(f'Weight:{self.weight}') personal=Person() print(personal.print_person()) # passing member of one class to other class class Student: this=111 #constructer geeky show def __init__(self,n,r): self.name=n self.roll=r # instance method def disp(self): print("AAAAA",self.name) print("AAAAA roll",self.roll) class user: @staticmethod def show(s): print("BBBBB",s.name) print("BBBBB",s.roll) s.disp() #optional #creating object of student class stu=Student("turab",101) stu1=Student("Hussain",110) user.show(stu) class user1: @staticmethod def show1(ss): print("CCCCC",ss.name) print("CCCCC",ss.roll) ss.disp() # optional user1.show1(stu) print(Student.this) #self #self class Teacher: uniform ="white dress" def __init__(self,name,grade,experience): self.name=name self.grade=grade self.experience=experience def avg (self): print(f'Person Name: {self.name}') print(f'Person Grade: {self.grade}') print(f'Person Experience: {self.experience}') def get_name(self): return self.name def set_name(self,value): self.name=value @classmethod def art(cls): return cls.Teacher @staticmethod def mart(): print("this is test string") obj=Teacher("turab",'A',20) print(obj.avg()) print(obj.get_name()) obj.set_name("hussain") print(obj.get_name()) print(Teacher.uniform) print(Teacher.mart()) # setter and getter classmethod and static method class Student: school="code tune" def __init__ (self,name,m1,m2,m3): self.name=name self.m1=m1 self.m2=m2 self.m3=m3 def avg(self): return(self.m1+self.m2+self.m3)/3 def get_name(self): #getter method to get data only return self.name def set_name(self,value): #setter method for set/change data self.name=value @classmethod #class method acces class attribute data only def getschoolname(cls): return cls.school @staticmethod # static method do not access other function data def info(): print('this is just test method') std1=Student("Kamran",45,38,42) std2=Student("Irfan",42,44,32) print(std1.avg()) print(std2.avg()) print(std1.get_name()) std1.set_name("Murad") print(std1.get_name()) print(Student.getschoolname()) print(Student.info()) # use of operatorkonze build instance method def operator(promotion,x,y): return promotion(x,y) def add(x,y): return"x"+"y" def sub(x,y): return x-y def mult(x,y): return x*y if __name__== "__main__" : print(operator(add,23,42)) print(operator(sub,23,42)) print(operator(mult,23,42)) def succ(function): def operation(*args): result=function(*args) return result+11 return operation @succ # use @ function get direct result with object def add(x,y): return x+y if __name__ == "__main__": add_plus=(succ(add)) # making object print(add_plus(23,42)) print(add(23,42)) # no object necessay direct result class Accumulator: def __init__(self): self.acc=0 def add(self,x): self.acc+=x @staticmethod # have no excess to class or mehod def sub(x,y): return x-y if __name__ == "__main__": a=Accumulator() a.add=23 a.add=42 print(a.acc) print(Accumulator.sub (23,42)) # ??? # difrerent format making method (corey) firstname="turab" lastname="bhai" sentence=("my name is {} {}".format (firstname,lastname)) print(sentence) sentence=( f'my name is "{firstname} {lastname}"') print (sentence) sentence= (f'"{firstname}" "{lastname}"') print(sentence) person={'name':'turab' ,'age':74} sentence=(f"my name is {person['name']}and i am age {person ['age']}") print (sentence) for n in range (1,3): sentence =(f'the value is {n}') print (sentence) pi=3.14159265 sentence= (f'the pi is equal to {pi:.3f}') print (sentence) # getter,setter and deleter method class Fruits: def __init__ (self,name:str): self._name=name @property # @property work as getter method def fruity_name(self): print(f'"{self._name}" was accessed') return self._name @fruity_name.setter def fruito_name(self,value): print(f'"{self._name}"is now"{value}"') self._name=value @fruito_name.deleter def fruitu_name(self): print(f'"{self._name}"was deleted') if __name__ == "__main__": fruit=Fruits("Banana") fruit.fruity_name fruit.fruito_name="Orange" del fruit.fruitu_name # @classmethod access to (class function) # @classmethod access to (class function) class Mobile: @classmethod def showw_model(cls): print("Real me X") @staticmethod def wolf (): print ("wolf") obj=Mobile() obj.showw_model() Mobile.wolf() # @classmethod access to (class attribute and function) class NewMobile: fp="yes" @classmethod def showyes_model(cls): print("fingerprint:",cls.fp) NewMobile.showyes_model() # retrive inf from same name function with super() class ws: def displayinfo(self,name= ""): print("welcome"+name) class tip(ws): def displayinfo(self): super().displayinfo() print("welcom to tip") obj=tip() obj.displayinfo() obj=ws() obj.displayinfo() obj.displayinfo(" to python") class Encapsule: __name="turab" def __init__ (self): print (self.__name) self.__displayinfo() def __displayinfo(self): print("welcome to knowledge") obj=Encapsule() # __init__ method over ride previous __init__ method class flower: # setter and getter method def __init__ (self): self.type="sun flower" def get_name(self): return self.type def __init__ (self): self.type="lilly" def set_name(self): return self.type f=flower() a=f.set_name() print(a) a=f.set_name() print(a) # __init__ method over ride previous __init__ method class flower: #setter and getter method def __init__ (self): self.type="sun flower" def get_name(self): return self.type f=flower() a=f.get_name() print(a) class flower: def __init__ (self): self.type="lilly" def set_name(self): return self.type f=flower() a=f.set_name() print(a) class Employee: def Name(self,n): self.n=n def getName(self): return self.n e1=Employee() e2=Employee() e1.Name("OO") e2.Name("HH") print("e1 object is",e1.__dict__ ) print("e2 object is",e2.__dict__ ) e1.getName() e2.getName() class Student: def setName(self,n): self.name=n def getName(self): return self.__name #print(self.__name) def setMarks(self,m): self.marks=m def getMarks(self): print(self.__marks) #return self.__marks def display(self): print("Name",self.name) print("Marks",self.marks) def displa(self): # two time display data in same class print(self.name) print(self.marks) S=Student() S.setName("Turab nomanbhai") S.setMarks("85.25") S.display() S.displa() #(1) here x value argumet is put 34 in parentesiy aa=lambda x:x+5 print(aa(34)) #(2)x value is not given automatically acquires eqval to value a a=550 bb=lambda x:a/x print(bb(a)) #(3) x value is given 10 as argument for x a=5 cc= lambda x:a+x print(cc(10)) #(4) reads length of string included spaces too dd=len("kkkkkkkk ") print(dd) # changes the values in list ee=[7,8,9,11,] #(5) ee[2]=100 ee[3]="yy" print(ee) #(6) print in the formation of list ii=range(1,10) print(list(ii)) #(7) changes the (values) in the directory jj={2:9,4:0,5:88,7:"kk"} print(jj) jj[2]=77 jj[7]=770 print(jj) # changes directory(values)not the (key) # changes directory(values)not the (key) kk={2:81,4:42,5:55,62:"kdo",} # (8) print(kk) kk[2]=101 kk[7]="ttyo" print(kk) #class (object) should have 4 attribute values. #class (object) should have 4 attribute values. class Book: #(9) def __init__ (self ,pages,price,topic,color): self.pages=pages self.price=price self.topic=topic self.color=color row_1=Book(100,"$40.00","History","Redbook") row_2=Book(400,"$65.00","Auto mechanic","Bluebook") print(row_1.topic) print(row_2.price) print(row_2.topic) #(10) class have its own attribute value separately class Dog: legs=4 def __init__(self, name, color): self.name=name self.color=color fido=Dog("Fido","brown") print(fido.legs) print(Dog.legs) # list slices from 0 index to 5 th index ll=[33,88,99,77,11,55,68,67,54,] #(11) print(ll[0:5]) # list slices from third index to the end every 1 step skipping mm =[4,7,8,44,11,90,100,34,37,90,50,"jj"] #(12) print (mm[3::2]) # slicing list from 0 index to 6 indexe nn=[4,9,0,7,19,18,5,90,34,66.70,80,] #(13) print (nn[:6]) # slicing list from 5 index to the end oo=[1,0,8,6,16,401,50,44,88,60,49,101,] #(14) print(oo[5:]) #showing list 0 and 5 th index value only pp=[57,7,0,8,1,87,60,50,40,9,] #(15) print(pp[::5]) # list slicing forward until stops(-2) index backward qq=[6,8,11,0,7,81,18,61,40,70,92,73,81,] #(16) print(qq[4:-2]) y=10 #(17) rr=(lambda x:x+y) print(rr(21)) #(18) formated either side indexes changed mannually by choice # directory is modified automatically file=["i","am","heading","for","work","very","soon."] oak=("{0}{1}{2}{3}{4}{5}{6}".format(file[0],file[1],file[2],file[3],file[4],file[5],file[6],)) print(oak) #(19) print formated indexes autmaically # blank directory modified automaically file=["i","am","heading","for","work","very","soon."] oak=("{}{}{}{}{}{}{}".format(file[0],file[1],file[2],file[3],file[4],file[5],file[6],)) print(oak) #(20) print indexes by selected choice #directory is modified manually file=["i","am","heading","for","work","very","soon."] oak=("{6}{6}{6}{6}{6}{6}{6}".format(file[0],file[1],file[2],file[3],file[4],file[5],file[6],)) print(oak) # print by index number as in the format list file=["i","am","heading","for","work","very","soon."] #(21) oak=("{0}{1}{2}{3}{4}{5}{6}".format(file[1],file[1],file[1],file[1],file[1],file[1],file[1],)) print(oak) def rr(a,b): #(22)list map is made by up and down vertical pair return a+8,b*9 ss=[3,9,10,] # a value work with ss kk=[5,1,7,] # b value work with kk gg=list(map(rr,ss,kk)) print(gg) #(23) list is map in row up and down manner vertically def rr(a,b,c): return a+8,b*9,c+8 ss=[81,3,6,11] kk=[2,8,17,13] pp=[11,5,7,31] gg=list(map(rr,ss,kk,pp,)) print(gg) #each index is calculated in list per instruction given in return vertically def rr(v,y,t): #(24) return v+8,y*9,t+10, ss=[5,8,9,10,33] kk=[4,6,9,44,22] pp=[3,8,7,33,11] gg=list(map(rr,ss,kk,pp,)) print(gg) def rr(): #(25) print("HELLOW WORLD!") rr() def bixx(): # (25a) nothing in memory print(bixx) def rr(vs): #(26) vs value is here 81 return vs*83 print(rr(81)) #(27) memory is added in print when def rr is recalled def rr(page): print("few white roses"+page) rr("are available.") tt={97,6,9,0,1,22,91,90,} #(28) pr={5,6,9,0,14,18,100,2,} print(tt|pr) #combine in list common included print(tt^pr) #combine common in list excluded print(tt&pr) # only common in list print(tt-pr) # do not show common in list print(pr-tt) # do not show common in list # adding 2 list uu=[97,6,9,0,1,22,91,90,] #(29) pr=[5,6,9,0,14,18,100,2,] print(uu+pr) # adding 2 list vv=[7,8,9,0,] #(30) pr=[1,0,55,90,] print(pr+vv) #" + self.cont result += ">" + other.cont[index:] print(result) spam = SpecialString("spam") eggs = SpecialString("eggs") spam > eggs print("eggs"[:0]) #(46) print("eggs"[:1]) print("eggs"[:2]) print("eggs"[:3]) print("eggs"[:4]) #More magic methods for common operators: # (47) #__sub__ for - #__mul__ for * #__truediv__ for / #__floordiv__ for // #__mod__ for % #__pow__ for ** #__and__ for & #__xor__ for ^ #__or__ for | #__lt__ for < #(48) #__le__ for <= #__eq__ for == #__#ne__ for != #__gt__ for > #__ge__ for >= # #If __ne__ is not implemented, it returns the opposite of __eq__. #There are no other relationships between the other operators. #Example: class garment: #(49) def __init__ (self,color,size,condition): self.color=color self.size=size self.condition=condition def auction(self): print ("very good price") oak=garment("blue","XL","new") oak.auction () print (oak.condition) a=[6,8,0,5,4,3] #(50) print (a [:])# print all a=[8,9,0,5,3,2,11] #(51) print(a [:3]) # index 0 to 3 a=[9,7,4,3,0,7,5,8,22] #(52) print (a [1:4]) #print index 1 to 4 values a=[8,5,9,11,34,7,8,10,11,] #(53) print(a [2:]) # print value in index 2 and forward a=[8,7,5,0,8,3,20,10,44,89,] # (54) print (a [:3]) #print index value index 3 to index 0 backward a=[44,9,0,6,77,44,8,90,5,98,60,] #(55) print (a [0::7]) # print index value in 0 and 7 only class Garments: #(56) def __init__ (self, size,color,fabric,gender,): self.size =size self.color=color self.fabric=fabric self.gender=gender def moreo(self): print ("good quality "+ xl.size ) xl=Garments("XL","red","softdenin","male",) xl.moreo () print(xl.size) class chairman: #(57) def __init__ (self, size,color,fabric,gender,): self.size =size self.color=color self.fabric=fabric self.gender=gender def moreo(self): print("good quality "+ xl.size,mew.size) def kov (self): print("all right " + mew.size) mew=chairman ("24 inces","rosered","cotton","women",) mew.kov () xl=chairman("XL","red","softdenin","male",) xl.moreo () class A: #(58) def method(self): print("A method") class B(A): def another_method(self): print("B method") class C(B): def third_method(self): print("C method") c = C() c.method() c.another_method() c.third_method() class A: #(59) def spam(self): print(1) class B(A): def spam(self): print(2) super().spam() B().spam() class royal: #(60) def __init__ (self ,x,y,u): self.x =x self.y=y self.u=u def __add__ (self,other): return royal(self.x +other.x , self.y +other.y ,self.u +other.u) arch=royal (13,39,77) marc=royal (33,90,67) kok=arch+marc print (kok.x) print (kok.y) print (kok.u) class bookline: #(61) def __init__ (self,count): self.count=count def __truediv__ (self,mark): lineo= "-" * len(mark.count) return "\n".join ([self.count,lineo,mark.count]) beo=bookline ("jointventure") deo=bookline("noargumentok") print (beo/deo) class Artist: #(62) def __init__ (self,make): self.make=make def __truediv__ (self,kake): line = "-" * len (kake.make) return "\n".join ([self.make,line,kake.make]) vv=Artist("mohenjodaro in Sindh") bb=Artist("Historical place") print(vv/bb) a = [1,2,3,4,5] #(63) print(a) #(result : [1,2,3,4,5]) b = a b.pop(0) print(a) #(result : [2,3,4,5]) a = 42 # Create object <42> #(64) b = a # Increase ref. count of <42> c = [a] # Increase ref. count of <42> print ("Before deletion") print (a, b, c) del a # Decrease ref. count of <42> b = 100 # Decrease ref. count of <42> c[0] = -1 # Decrease ref. count of <42> print ("After deletion") print (b, c) #Remove this line and run once. Again put this line and run. #After executing the above code on code playground, you will get it. class Pair_of_numbers: #(65)??????????????????????????????????????? def __init__(self, x, y): self.x = x self.y = y def __truediv__ (self, other): return Pair_of_numbers(self.x / other.x, self.y / other.y) class Pair_of_numbers2: #(66) def __init__(self, x, y): self.x = x self.y = y def __rtruediv__ (self, other): return Pair_of_numbers(self.x / other.x, self.y / other.y) pair_1 = Pair_of_numbers(100,5) pair_2 = Pair_of_numbers2(2,5) result = pair_1 / pair_2 print (result.x) print (result.y) print ("ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc") class Pair_of_numbers:#(67)?????????????????????????????????????????????????? def __init__(self, x, y): self.x = x self.y = y #def __truediv__ (self, other): #return Pair_of_numbers(self.x / other.x, self.y / other.y) class Pair_of_numbers2: def __init__(self, x, y): self.x = x self.y = y def __rtruediv__ (self, other): return Pair_of_numbers(self.x / other.x, self.y / other.y) pair_1 = Pair_of_numbers(10,50) pair_2 = Pair_of_numbers2(2,5) result = pair_1 / pair_2 print (result.x) print (result.y) class Queue: #(68) def __init__(self, contents): self._hiddenlist = list(contents) def push(self, value): self._hiddenlist.insert(0, value) # 0 is added in the coloum def pop(self): return self._hiddenlist.pop(-3) #backward 3rd coloum deleted def __repr__(self): return "Queue({})".format(self._hiddenlist) queue = Queue([1, 2, 3,4,5,6,7,8,9,]) print(queue) queue.push(11) # 11 is pushed in a row print(queue) queue.pop() print(queue) print(queue._hiddenlist) class Queue: #(96)??????????????????????????????????? def __init__(self,contents): self.one=contents def push(self,value): self.one.insert(0,value) def pop(self): return self.one.pop(-2) def __repr__(self): return "Queue({})".format(self.one) queue=Queue([1,2,3]) print(queue) queue.push(0) print(queue) queue.pop() print(queue) print(queue.one) class Spam: #(69) __egg = 7 def print_egg(self): print(self.__egg) s = Spam() s.print_egg() print(s._Spam__egg) #print(s.__egg) class Rectangle: #(70) def __init__(self, width, height): self.width = width self.height = height def calculate_area(self): return self.width * self.height @classmethod def new_square(cls, side_length,s_s): return cls(side_length, s_s) square = Rectangle.new_square(5,50) print(square.calculate_area()) class dimond: # (71) def __init__(self, name): self.name = name @classmethod def sayHi(cls): print ("Hii") dimond.sayHi () class Person: # (72) def __init__(self, name): self.name = name @classmethod def sayHi(cls): print("Hio") Person.sayHi() class worker: # (73) def __init__(self, name): self.name = name def sayHi(self): print("Hiwho") worker.sayHi ("") # parenthies must have any string for name attribute class Pizza: #(74) def __init__(self, toppings): self.toppings = toppings @staticmethod def validate_topping(topping): if topping == "pineapple": raise ValueError("No pineapples!") else: return True def __repr__(self): return "Pizza({})" . format(self.toppings) ingredients = ["cheese", "onions", "spam"] # List Functions often used in conditional statements, all and any take a list as an argument, and return True if all or any (respectively) of their arguments evaluate to True (and False otherwise). if all([Pizza.validate_topping(i) for i in ingredients]): pizza = Pizza(ingredients) print(pizza) # Output: Pizza(["cheese", "onions", "spam"]) import re s="aba . @ dfgh ,/ 11.11 ... " a= re.match (pattern="\w",string=s) print (a) a=re.search("\w",s) print (a) a=re.findall("\w",s) print(a) a=re.findall("\d+",s) print(a) a=re.findall("\W+",s) print(a) a=re.sub("^\w\s",repl=" ",string=s) print(a) a=re.sub ("\.?" ,repl=" ",string=s) print(a) class Pizza: #(75) def __init__(self, toppings): self.toppings = toppings @staticmethod def validate_topping(topping): if topping == "pineapple": raise ValueError("No pineapples!") else: return True ingredients = ["cheese", "onions", "spam"] if all(Pizza.validate_topping(i) for i in ingredients): pizza = Pizza(ingredients) print (pizza.toppings) class Adult: #(76) def __init__(self,age): self.age = int(age) @property def isadult(self): if self.age > 18: return True else: return False a = Adult(25) print(a.isadult) class Wolf: #(77) def __init__(self,name,color): self.name=name self.color=color def bark(self): print("Grr...") class Dog(Wolf): # If a class inherits from another with the same attributes or methods, it overrides them. def bark(self): print("Woof") husky=Dog("Max","grey") husky.bark() # Inheritance can also be indirect, # One class can inherit from another, # and that class can inherit from a third class. class A: #(78) def method(self): print("A method") class B(A): def another_method(self): print("B method") class C(B): def third_method(self): print("C method") c=C() c.method() c.another_method() c.third_method() # Inheritance can also be indirect, # One class can inherit from another, # and that class can inherit from a third class. class A: #(79) def method(self): print("A method") class B(A): def another_method(self): print("B method") class C(B): def third_method(self): print("C method") super().another_method() c=C() c.third_method() class A: #(80) def spam(self): print(1) class B(A): def page(self): print(2) super().spam() #The function super is a useful inheritance-related function that refers to the parent class. It can be used to find the method with a certain name in an object's superclass. B().page() class A: # (81) def spam(self): print(1) class B(A): def spam(self): print(2) B().spam() class SpecialString: #(82) def __init__(self,cont): self.cont=cont def __gt__(self,other): for index in range(len(other.cont)+1): result=other.cont[:index]+">"+self.cont result+=">"+other.cont[index:] print(result) spam=SpecialString("spam") eggs=SpecialString("eggs") spam>eggs class math1: #(83) def __init__(self,x,y,c): self.x=x self.y=y self.c=c def __add__(self,other): return math1(self.x+other.x,self.y*other.y,self.c+other.c) first=math1(5,7,66) second=math1(3,9,55) third=math1(8,9,10) result=first+second+third print(result.x) print(result.y) print(result.c) class math2: #(84) def __init__(self,cont): self.cont=cont def __truediv__(self,other): line="?"*len(other.cont) return "\n".join([self.cont,line,other.cont]) oman=math2("RED ROSES STILL CAN") hello=math2("NOT FIND ON THE WAY") print(oman/hello) class math3: #(85) def __init__(self,cont): self.cont=cont def __truediv__(self,other): line = "" * len(other.cont) return "".join([self.cont,line,other.cont]) oman=math3("RED ROSES STILL CAN") hello=math3("NOT FIND ON THE WAY") print(oman/hello) class math4: #??? #(86) def __init__(self,cont): self.cont=cont def __add__(self,other): line="="*len(other.cont) return "\n".join([self.cont,line,other.cont]) oman=math4("spam") hello=math4("Hello world!") print(oman+hello) class math5: #??? #(87) def __init__(self,cont): self.cont=cont def __gt__(self,other): for index in range(len(other.cont)+1): result=other.cont[:index]+">"+self.cont result+=">"+other.cont[index:] print(result) spam=math5("spam") eggs=math5("eggs") spam>eggs #self.cont is 1st defination class SpecialString: #(88) def __init__(self,cont): self.cont=cont def __gt__(self,other): for index in range(len(other.cont)+1): result=self.cont+">" print(result) spam=SpecialString("ELEPHANT") eggs=SpecialString("eggs") spam>eggs # other.cont is 2nd defination class SpecialString: #(89) def __init__(self,cont): self.cont=cont def __gt__(self,other): for index in range(len(other.cont)+1): result=other.cont+">" print(result) spam=SpecialString("spam") eggs=SpecialString("LOIN") spam>eggs #??? class SpecialString: #(90) def __init__(self,cont): self.cont=cont def __gt__(self,other): for index in range(len(other.cont)+1): result=other.cont[:index]+"@@@@@@@" print(result) spam=SpecialString("spam") eggs=SpecialString("eggs") spam>eggs spameggs spam #(94) b=a # Increase ref. count of <42> c=[a] # Increase ref. count of <42> print("Before deletion") print (a,b,c) del a # Decrease ref. count of <42> b=100 # Decrease ref. count of <42> c[0]=-1 # Decrease ref. count of <42> print("After deletion") print(b,c) print # Remove this line and run once. Again put this line and run. # (push) value 4 is pushed in index 0 # (pop) end index as is removed # modified final list printed class Queue: #(96) def __init__(self,contents): self._hiddenlist=contents def push(self,value): self._hiddenlist.insert(0,value) def pop(self):# (pop) end index as is removed return self._hiddenlist.pop(-1) def __repr__(self): return "Queue({})".format(self._hiddenlist) queue=Queue([1,2,3]) print(queue) queue.push(4)# (push) value 4 is pushed in index 0 print(queue) queue.pop() print(queue) print(queue._hiddenlist) class Spam: #(97)?????????????????????????????????? __egg=7 def print_egg(self): print(self.__egg) s = Spam() s.print_egg() print(s._Spam__egg) #print(s.__egg) class Spam: #(98)?????????????????????????????????? __egg=8 def oak(self): print(self.__egg) s = Spam() s.oak() print(s._Spam__egg) #??? class Rectangle: #(99) def __init__(self, width,height): self.width=width self.height=height def calculate_area(self): return self.width*self.height @classmethod def new_square(cls,side_length): return cls(side_length, side_length) square=Rectangle.new_square(6) print(square.calculate_area()) #??? class Rectangle: # (100) def __init__(self,width,height): self.width=width self.height=height def oak(self): return self.width*self.height @classmethod def kok(cls, side_length): return cls(side_length,side_length) square=Rectangle.kok(2) print(square.oak()) # rectangle area calculate with given dimentions def rectangle_area (width,length,none,): #(100a) return (width(length(none))) def width(x): return x*12 def length(y): return y*7 print (rectangle_area(width,length,1)) #(100b) cubic volume calculate with given dimentions def cubic_volume(width,length,depth): return (width(length(depth))) def width(x): return x*4 def length(y): return y*4 print (cubic_volume(width,length,4)) #??? foo=print() # (101) if print==None: print(1) else: print(29) # pizza.pineapple_allowed = True ?????? class Pizza: # (102) def __init__(self,toppings): self.toppings=toppings @property def pineapple_allowed(self): return False pizza=Pizza(["cheese","tomato"]) print(pizza.pineapple_allowed) # Class attributes are shared by all instances of the class. # it define supper class attribute by itself class Dog: #(103) legs=4 def __init__(self,name,color): self.name=name self.color=color fido = Dog("Fido","brown") print(fido.legs) print(Dog.legs) #inherited class from another class,place superclass name in parentheses #after the class name class Animal: def __init__(self,name,color): #(104) self.name=name self.color=color class Cat(Animal): def purr(self): print("Purr...") class Dog(Animal): def bark(self): print("Woof!") fido=Dog("Fido","brown") print(fido.color) fido.bark()

Functions plus Answers (4)