Data Abstraction Operator Overloading
Mon 30 June 2025
# Cell 1 - Data Abstraction Example
class Example1:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 1
obj1 = Example1(1)
print(obj1.get_value())
1
# Cell 2 - Data Abstraction Example
class Example2:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 2
obj2 = Example2(2)
print(obj2.get_value())
4
# Cell 3 - Data Abstraction Example
class Example3:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 3
obj3 = Example3(3)
print(obj3.get_value())
9
# Cell 4 - Data Abstraction Example
class Example4:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 4
obj4 = Example4(4)
print(obj4.get_value())
16
# Cell 5 - Data Abstraction Example
class Example5:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 5
obj5 = Example5(5)
print(obj5.get_value())
25
# Cell 6 - Data Abstraction Example
class Example6:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 6
obj6 = Example6(6)
print(obj6.get_value())
36
# Cell 7 - Data Abstraction Example
class Example7:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 7
obj7 = Example7(7)
print(obj7.get_value())
49
# Cell 8 - Data Abstraction Example
class Example8:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 8
obj8 = Example8(8)
print(obj8.get_value())
64
# Cell 9 - Data Abstraction Example
class Example9:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 9
obj9 = Example9(9)
print(obj9.get_value())
81
# Cell 10 - Data Abstraction Example
class Example10:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 10
obj10 = Example10(10)
print(obj10.get_value())
100
# Cell 11 - Data Abstraction Example
class Example11:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 11
obj11 = Example11(11)
print(obj11.get_value())
121
# Cell 12 - Data Abstraction Example
class Example12:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 12
obj12 = Example12(12)
print(obj12.get_value())
144
# Cell 13 - Data Abstraction Example
class Example13:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 13
obj13 = Example13(13)
print(obj13.get_value())
169
# Cell 14 - Data Abstraction Example
class Example14:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 14
obj14 = Example14(14)
print(obj14.get_value())
196
# Cell 15 - Data Abstraction Example
class Example15:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 15
obj15 = Example15(15)
print(obj15.get_value())
225
# Cell 16 - Data Abstraction Example
class Example16:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 16
obj16 = Example16(16)
print(obj16.get_value())
256
# Cell 17 - Data Abstraction Example
class Example17:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 17
obj17 = Example17(17)
print(obj17.get_value())
289
# Cell 18 - Data Abstraction Example
class Example18:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 18
obj18 = Example18(18)
print(obj18.get_value())
324
# Cell 19 - Data Abstraction Example
class Example19:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 19
obj19 = Example19(19)
print(obj19.get_value())
361
# Cell 20 - Data Abstraction Example
class Example20:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 20
obj20 = Example20(20)
print(obj20.get_value())
400
# Cell 21 - Data Abstraction Example
class Example21:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 21
obj21 = Example21(21)
print(obj21.get_value())
441
# Cell 22 - Data Abstraction Example
class Example22:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 22
obj22 = Example22(22)
print(obj22.get_value())
484
# Cell 23 - Data Abstraction Example
class Example23:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 23
obj23 = Example23(23)
print(obj23.get_value())
529
# Cell 24 - Data Abstraction Example
class Example24:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 24
obj24 = Example24(24)
print(obj24.get_value())
576
# Cell 25 - Data Abstraction Example
class Example25:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 25
obj25 = Example25(25)
print(obj25.get_value())
625
# Cell 26 - Data Abstraction Example
class Example26:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 26
obj26 = Example26(26)
print(obj26.get_value())
676
# Cell 27 - Data Abstraction Example
class Example27:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 27
obj27 = Example27(27)
print(obj27.get_value())
729
# Cell 28 - Data Abstraction Example
class Example28:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 28
obj28 = Example28(28)
print(obj28.get_value())
784
# Cell 29 - Data Abstraction Example
class Example29:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 29
obj29 = Example29(29)
print(obj29.get_value())
841
# Cell 30 - Data Abstraction Example
class Example30:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 30
obj30 = Example30(30)
print(obj30.get_value())
900
# Cell 31 - Data Abstraction Example
class Example31:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 31
obj31 = Example31(31)
print(obj31.get_value())
961
# Cell 32 - Data Abstraction Example
class Example32:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 32
obj32 = Example32(32)
print(obj32.get_value())
1024
# Cell 33 - Data Abstraction Example
class Example33:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 33
obj33 = Example33(33)
print(obj33.get_value())
1089
# Cell 34 - Data Abstraction Example
class Example34:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 34
obj34 = Example34(34)
print(obj34.get_value())
1156
# Cell 35 - Data Abstraction Example
class Example35:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 35
obj35 = Example35(35)
print(obj35.get_value())
1225
# Cell 36 - Data Abstraction Example
class Example36:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 36
obj36 = Example36(36)
print(obj36.get_value())
1296
# Cell 37 - Data Abstraction Example
class Example37:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 37
obj37 = Example37(37)
print(obj37.get_value())
1369
# Cell 38 - Data Abstraction Example
class Example38:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 38
obj38 = Example38(38)
print(obj38.get_value())
1444
# Cell 39 - Data Abstraction Example
class Example39:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 39
obj39 = Example39(39)
print(obj39.get_value())
1521
# Cell 40 - Data Abstraction Example
class Example40:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 40
obj40 = Example40(40)
print(obj40.get_value())
1600
# Cell 41 - Data Abstraction Example
class Example41:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 41
obj41 = Example41(41)
print(obj41.get_value())
1681
# Cell 42 - Data Abstraction Example
class Example42:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 42
obj42 = Example42(42)
print(obj42.get_value())
1764
# Cell 43 - Data Abstraction Example
class Example43:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 43
obj43 = Example43(43)
print(obj43.get_value())
1849
# Cell 44 - Data Abstraction Example
class Example44:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 44
obj44 = Example44(44)
print(obj44.get_value())
1936
# Cell 45 - Data Abstraction Example
class Example45:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 45
obj45 = Example45(45)
print(obj45.get_value())
2025
# Cell 46 - Data Abstraction Example
class Example46:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 46
obj46 = Example46(46)
print(obj46.get_value())
2116
# Cell 47 - Data Abstraction Example
class Example47:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 47
obj47 = Example47(47)
print(obj47.get_value())
2209
# Cell 48 - Data Abstraction Example
class Example48:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 48
obj48 = Example48(48)
print(obj48.get_value())
2304
# Cell 49 - Data Abstraction Example
class Example49:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 49
obj49 = Example49(49)
print(obj49.get_value())
2401
# Cell 50 - Data Abstraction Example
class Example50:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 50
obj50 = Example50(50)
print(obj50.get_value())
2500
# Cell 51 - Data Abstraction Example
class Example51:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 51
obj51 = Example51(51)
print(obj51.get_value())
2601
# Cell 52 - Data Abstraction Example
class Example52:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 52
obj52 = Example52(52)
print(obj52.get_value())
2704
# Cell 53 - Data Abstraction Example
class Example53:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 53
obj53 = Example53(53)
print(obj53.get_value())
2809
# Cell 54 - Data Abstraction Example
class Example54:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 54
obj54 = Example54(54)
print(obj54.get_value())
2916
# Cell 55 - Data Abstraction Example
class Example55:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 55
obj55 = Example55(55)
print(obj55.get_value())
3025
# Cell 56 - Data Abstraction Example
class Example56:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 56
obj56 = Example56(56)
print(obj56.get_value())
3136
# Cell 57 - Data Abstraction Example
class Example57:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 57
obj57 = Example57(57)
print(obj57.get_value())
3249
# Cell 58 - Data Abstraction Example
class Example58:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 58
obj58 = Example58(58)
print(obj58.get_value())
3364
# Cell 59 - Data Abstraction Example
class Example59:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 59
obj59 = Example59(59)
print(obj59.get_value())
3481
# Cell 60 - Data Abstraction Example
class Example60:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 60
obj60 = Example60(60)
print(obj60.get_value())
3600
# Cell 61 - Data Abstraction Example
class Example61:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 61
obj61 = Example61(61)
print(obj61.get_value())
3721
# Cell 62 - Data Abstraction Example
class Example62:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 62
obj62 = Example62(62)
print(obj62.get_value())
3844
# Cell 63 - Data Abstraction Example
class Example63:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 63
obj63 = Example63(63)
print(obj63.get_value())
3969
# Cell 64 - Data Abstraction Example
class Example64:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 64
obj64 = Example64(64)
print(obj64.get_value())
4096
# Cell 65 - Data Abstraction Example
class Example65:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 65
obj65 = Example65(65)
print(obj65.get_value())
4225
# Cell 66 - Data Abstraction Example
class Example66:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 66
obj66 = Example66(66)
print(obj66.get_value())
4356
# Cell 67 - Data Abstraction Example
class Example67:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 67
obj67 = Example67(67)
print(obj67.get_value())
4489
# Cell 68 - Data Abstraction Example
class Example68:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 68
obj68 = Example68(68)
print(obj68.get_value())
4624
# Cell 69 - Data Abstraction Example
class Example69:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 69
obj69 = Example69(69)
print(obj69.get_value())
4761
# Cell 70 - Data Abstraction Example
class Example70:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 70
obj70 = Example70(70)
print(obj70.get_value())
4900
# Cell 71 - Data Abstraction Example
class Example71:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 71
obj71 = Example71(71)
print(obj71.get_value())
5041
# Cell 72 - Data Abstraction Example
class Example72:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 72
obj72 = Example72(72)
print(obj72.get_value())
5184
# Cell 73 - Data Abstraction Example
class Example73:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 73
obj73 = Example73(73)
print(obj73.get_value())
5329
# Cell 74 - Data Abstraction Example
class Example74:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 74
obj74 = Example74(74)
print(obj74.get_value())
5476
# Cell 75 - Data Abstraction Example
class Example75:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 75
obj75 = Example75(75)
print(obj75.get_value())
5625
# Cell 76 - Data Abstraction Example
class Example76:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 76
obj76 = Example76(76)
print(obj76.get_value())
5776
# Cell 77 - Data Abstraction Example
class Example77:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 77
obj77 = Example77(77)
print(obj77.get_value())
5929
# Cell 78 - Data Abstraction Example
class Example78:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 78
obj78 = Example78(78)
print(obj78.get_value())
6084
# Cell 79 - Data Abstraction Example
class Example79:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 79
obj79 = Example79(79)
print(obj79.get_value())
6241
# Cell 80 - Data Abstraction Example
class Example80:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 80
obj80 = Example80(80)
print(obj80.get_value())
6400
# Cell 81 - Data Abstraction Example
class Example81:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 81
obj81 = Example81(81)
print(obj81.get_value())
6561
# Cell 82 - Data Abstraction Example
class Example82:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 82
obj82 = Example82(82)
print(obj82.get_value())
6724
# Cell 83 - Data Abstraction Example
class Example83:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 83
obj83 = Example83(83)
print(obj83.get_value())
6889
# Cell 84 - Data Abstraction Example
class Example84:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 84
obj84 = Example84(84)
print(obj84.get_value())
7056
# Cell 85 - Data Abstraction Example
class Example85:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 85
obj85 = Example85(85)
print(obj85.get_value())
7225
# Cell 86 - Data Abstraction Example
class Example86:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 86
obj86 = Example86(86)
print(obj86.get_value())
7396
# Cell 87 - Data Abstraction Example
class Example87:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 87
obj87 = Example87(87)
print(obj87.get_value())
7569
# Cell 88 - Data Abstraction Example
class Example88:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 88
obj88 = Example88(88)
print(obj88.get_value())
7744
# Cell 89 - Data Abstraction Example
class Example89:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 89
obj89 = Example89(89)
print(obj89.get_value())
7921
# Cell 90 - Data Abstraction Example
class Example90:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 90
obj90 = Example90(90)
print(obj90.get_value())
8100
# Cell 91 - Data Abstraction Example
class Example91:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 91
obj91 = Example91(91)
print(obj91.get_value())
8281
# Cell 92 - Data Abstraction Example
class Example92:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 92
obj92 = Example92(92)
print(obj92.get_value())
8464
# Cell 93 - Data Abstraction Example
class Example93:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 93
obj93 = Example93(93)
print(obj93.get_value())
8649
# Cell 94 - Data Abstraction Example
class Example94:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 94
obj94 = Example94(94)
print(obj94.get_value())
8836
# Cell 95 - Data Abstraction Example
class Example95:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 95
obj95 = Example95(95)
print(obj95.get_value())
9025
# Cell 96 - Data Abstraction Example
class Example96:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 96
obj96 = Example96(96)
print(obj96.get_value())
9216
# Cell 97 - Data Abstraction Example
class Example97:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 97
obj97 = Example97(97)
print(obj97.get_value())
9409
# Cell 98 - Data Abstraction Example
class Example98:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 98
obj98 = Example98(98)
print(obj98.get_value())
9604
# Cell 99 - Data Abstraction Example
class Example99:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 99
obj99 = Example99(99)
print(obj99.get_value())
9801
# Cell 100 - Data Abstraction Example
class Example100:
def __init__(self, value):
self.__value = value
def get_value(self):
return self.__value * 100
obj100 = Example100(100)
print(obj100.get_value())
10000
# Cell 101 - Operator Overloading Example
class Overload101:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload101(self.num + other.num + 101)
def __str__(self):
return f"Value: {self.num}"
objA101 = Overload101(101)
objB101 = Overload101(102)
result101 = objA101 + objB101
print(result101)
Value: 304
# Cell 102 - Operator Overloading Example
class Overload102:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload102(self.num + other.num + 102)
def __str__(self):
return f"Value: {self.num}"
objA102 = Overload102(102)
objB102 = Overload102(103)
result102 = objA102 + objB102
print(result102)
Value: 307
# Cell 103 - Operator Overloading Example
class Overload103:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload103(self.num + other.num + 103)
def __str__(self):
return f"Value: {self.num}"
objA103 = Overload103(103)
objB103 = Overload103(104)
result103 = objA103 + objB103
print(result103)
Value: 310
# Cell 104 - Operator Overloading Example
class Overload104:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload104(self.num + other.num + 104)
def __str__(self):
return f"Value: {self.num}"
objA104 = Overload104(104)
objB104 = Overload104(105)
result104 = objA104 + objB104
print(result104)
Value: 313
# Cell 105 - Operator Overloading Example
class Overload105:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload105(self.num + other.num + 105)
def __str__(self):
return f"Value: {self.num}"
objA105 = Overload105(105)
objB105 = Overload105(106)
result105 = objA105 + objB105
print(result105)
Value: 316
# Cell 106 - Operator Overloading Example
class Overload106:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload106(self.num + other.num + 106)
def __str__(self):
return f"Value: {self.num}"
objA106 = Overload106(106)
objB106 = Overload106(107)
result106 = objA106 + objB106
print(result106)
Value: 319
# Cell 107 - Operator Overloading Example
class Overload107:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload107(self.num + other.num + 107)
def __str__(self):
return f"Value: {self.num}"
objA107 = Overload107(107)
objB107 = Overload107(108)
result107 = objA107 + objB107
print(result107)
Value: 322
# Cell 108 - Operator Overloading Example
class Overload108:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload108(self.num + other.num + 108)
def __str__(self):
return f"Value: {self.num}"
objA108 = Overload108(108)
objB108 = Overload108(109)
result108 = objA108 + objB108
print(result108)
Value: 325
# Cell 109 - Operator Overloading Example
class Overload109:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload109(self.num + other.num + 109)
def __str__(self):
return f"Value: {self.num}"
objA109 = Overload109(109)
objB109 = Overload109(110)
result109 = objA109 + objB109
print(result109)
Value: 328
# Cell 110 - Operator Overloading Example
class Overload110:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload110(self.num + other.num + 110)
def __str__(self):
return f"Value: {self.num}"
objA110 = Overload110(110)
objB110 = Overload110(111)
result110 = objA110 + objB110
print(result110)
Value: 331
# Cell 111 - Operator Overloading Example
class Overload111:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload111(self.num + other.num + 111)
def __str__(self):
return f"Value: {self.num}"
objA111 = Overload111(111)
objB111 = Overload111(112)
result111 = objA111 + objB111
print(result111)
Value: 334
# Cell 112 - Operator Overloading Example
class Overload112:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload112(self.num + other.num + 112)
def __str__(self):
return f"Value: {self.num}"
objA112 = Overload112(112)
objB112 = Overload112(113)
result112 = objA112 + objB112
print(result112)
Value: 337
# Cell 113 - Operator Overloading Example
class Overload113:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload113(self.num + other.num + 113)
def __str__(self):
return f"Value: {self.num}"
objA113 = Overload113(113)
objB113 = Overload113(114)
result113 = objA113 + objB113
print(result113)
Value: 340
# Cell 114 - Operator Overloading Example
class Overload114:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload114(self.num + other.num + 114)
def __str__(self):
return f"Value: {self.num}"
objA114 = Overload114(114)
objB114 = Overload114(115)
result114 = objA114 + objB114
print(result114)
Value: 343
# Cell 115 - Operator Overloading Example
class Overload115:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload115(self.num + other.num + 115)
def __str__(self):
return f"Value: {self.num}"
objA115 = Overload115(115)
objB115 = Overload115(116)
result115 = objA115 + objB115
print(result115)
Value: 346
# Cell 116 - Operator Overloading Example
class Overload116:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload116(self.num + other.num + 116)
def __str__(self):
return f"Value: {self.num}"
objA116 = Overload116(116)
objB116 = Overload116(117)
result116 = objA116 + objB116
print(result116)
Value: 349
# Cell 117 - Operator Overloading Example
class Overload117:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload117(self.num + other.num + 117)
def __str__(self):
return f"Value: {self.num}"
objA117 = Overload117(117)
objB117 = Overload117(118)
result117 = objA117 + objB117
print(result117)
Value: 352
# Cell 118 - Operator Overloading Example
class Overload118:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload118(self.num + other.num + 118)
def __str__(self):
return f"Value: {self.num}"
objA118 = Overload118(118)
objB118 = Overload118(119)
result118 = objA118 + objB118
print(result118)
Value: 355
# Cell 119 - Operator Overloading Example
class Overload119:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload119(self.num + other.num + 119)
def __str__(self):
return f"Value: {self.num}"
objA119 = Overload119(119)
objB119 = Overload119(120)
result119 = objA119 + objB119
print(result119)
Value: 358
# Cell 120 - Operator Overloading Example
class Overload120:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload120(self.num + other.num + 120)
def __str__(self):
return f"Value: {self.num}"
objA120 = Overload120(120)
objB120 = Overload120(121)
result120 = objA120 + objB120
print(result120)
Value: 361
# Cell 121 - Operator Overloading Example
class Overload121:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload121(self.num + other.num + 121)
def __str__(self):
return f"Value: {self.num}"
objA121 = Overload121(121)
objB121 = Overload121(122)
result121 = objA121 + objB121
print(result121)
Value: 364
# Cell 122 - Operator Overloading Example
class Overload122:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload122(self.num + other.num + 122)
def __str__(self):
return f"Value: {self.num}"
objA122 = Overload122(122)
objB122 = Overload122(123)
result122 = objA122 + objB122
print(result122)
Value: 367
# Cell 123 - Operator Overloading Example
class Overload123:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload123(self.num + other.num + 123)
def __str__(self):
return f"Value: {self.num}"
objA123 = Overload123(123)
objB123 = Overload123(124)
result123 = objA123 + objB123
print(result123)
Value: 370
# Cell 124 - Operator Overloading Example
class Overload124:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload124(self.num + other.num + 124)
def __str__(self):
return f"Value: {self.num}"
objA124 = Overload124(124)
objB124 = Overload124(125)
result124 = objA124 + objB124
print(result124)
Value: 373
# Cell 125 - Operator Overloading Example
class Overload125:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload125(self.num + other.num + 125)
def __str__(self):
return f"Value: {self.num}"
objA125 = Overload125(125)
objB125 = Overload125(126)
result125 = objA125 + objB125
print(result125)
Value: 376
# Cell 126 - Operator Overloading Example
class Overload126:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload126(self.num + other.num + 126)
def __str__(self):
return f"Value: {self.num}"
objA126 = Overload126(126)
objB126 = Overload126(127)
result126 = objA126 + objB126
print(result126)
Value: 379
# Cell 127 - Operator Overloading Example
class Overload127:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload127(self.num + other.num + 127)
def __str__(self):
return f"Value: {self.num}"
objA127 = Overload127(127)
objB127 = Overload127(128)
result127 = objA127 + objB127
print(result127)
Value: 382
# Cell 128 - Operator Overloading Example
class Overload128:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload128(self.num + other.num + 128)
def __str__(self):
return f"Value: {self.num}"
objA128 = Overload128(128)
objB128 = Overload128(129)
result128 = objA128 + objB128
print(result128)
Value: 385
# Cell 129 - Operator Overloading Example
class Overload129:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload129(self.num + other.num + 129)
def __str__(self):
return f"Value: {self.num}"
objA129 = Overload129(129)
objB129 = Overload129(130)
result129 = objA129 + objB129
print(result129)
Value: 388
# Cell 130 - Operator Overloading Example
class Overload130:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload130(self.num + other.num + 130)
def __str__(self):
return f"Value: {self.num}"
objA130 = Overload130(130)
objB130 = Overload130(131)
result130 = objA130 + objB130
print(result130)
Value: 391
# Cell 131 - Operator Overloading Example
class Overload131:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload131(self.num + other.num + 131)
def __str__(self):
return f"Value: {self.num}"
objA131 = Overload131(131)
objB131 = Overload131(132)
result131 = objA131 + objB131
print(result131)
Value: 394
# Cell 132 - Operator Overloading Example
class Overload132:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload132(self.num + other.num + 132)
def __str__(self):
return f"Value: {self.num}"
objA132 = Overload132(132)
objB132 = Overload132(133)
result132 = objA132 + objB132
print(result132)
Value: 397
# Cell 133 - Operator Overloading Example
class Overload133:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload133(self.num + other.num + 133)
def __str__(self):
return f"Value: {self.num}"
objA133 = Overload133(133)
objB133 = Overload133(134)
result133 = objA133 + objB133
print(result133)
Value: 400
# Cell 134 - Operator Overloading Example
class Overload134:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload134(self.num + other.num + 134)
def __str__(self):
return f"Value: {self.num}"
objA134 = Overload134(134)
objB134 = Overload134(135)
result134 = objA134 + objB134
print(result134)
Value: 403
# Cell 135 - Operator Overloading Example
class Overload135:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload135(self.num + other.num + 135)
def __str__(self):
return f"Value: {self.num}"
objA135 = Overload135(135)
objB135 = Overload135(136)
result135 = objA135 + objB135
print(result135)
Value: 406
# Cell 136 - Operator Overloading Example
class Overload136:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload136(self.num + other.num + 136)
def __str__(self):
return f"Value: {self.num}"
objA136 = Overload136(136)
objB136 = Overload136(137)
result136 = objA136 + objB136
print(result136)
Value: 409
# Cell 137 - Operator Overloading Example
class Overload137:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload137(self.num + other.num + 137)
def __str__(self):
return f"Value: {self.num}"
objA137 = Overload137(137)
objB137 = Overload137(138)
result137 = objA137 + objB137
print(result137)
Value: 412
# Cell 138 - Operator Overloading Example
class Overload138:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload138(self.num + other.num + 138)
def __str__(self):
return f"Value: {self.num}"
objA138 = Overload138(138)
objB138 = Overload138(139)
result138 = objA138 + objB138
print(result138)
Value: 415
# Cell 139 - Operator Overloading Example
class Overload139:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload139(self.num + other.num + 139)
def __str__(self):
return f"Value: {self.num}"
objA139 = Overload139(139)
objB139 = Overload139(140)
result139 = objA139 + objB139
print(result139)
Value: 418
# Cell 140 - Operator Overloading Example
class Overload140:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload140(self.num + other.num + 140)
def __str__(self):
return f"Value: {self.num}"
objA140 = Overload140(140)
objB140 = Overload140(141)
result140 = objA140 + objB140
print(result140)
Value: 421
# Cell 141 - Operator Overloading Example
class Overload141:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload141(self.num + other.num + 141)
def __str__(self):
return f"Value: {self.num}"
objA141 = Overload141(141)
objB141 = Overload141(142)
result141 = objA141 + objB141
print(result141)
Value: 424
# Cell 142 - Operator Overloading Example
class Overload142:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload142(self.num + other.num + 142)
def __str__(self):
return f"Value: {self.num}"
objA142 = Overload142(142)
objB142 = Overload142(143)
result142 = objA142 + objB142
print(result142)
Value: 427
# Cell 143 - Operator Overloading Example
class Overload143:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload143(self.num + other.num + 143)
def __str__(self):
return f"Value: {self.num}"
objA143 = Overload143(143)
objB143 = Overload143(144)
result143 = objA143 + objB143
print(result143)
Value: 430
# Cell 144 - Operator Overloading Example
class Overload144:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload144(self.num + other.num + 144)
def __str__(self):
return f"Value: {self.num}"
objA144 = Overload144(144)
objB144 = Overload144(145)
result144 = objA144 + objB144
print(result144)
Value: 433
# Cell 145 - Operator Overloading Example
class Overload145:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload145(self.num + other.num + 145)
def __str__(self):
return f"Value: {self.num}"
objA145 = Overload145(145)
objB145 = Overload145(146)
result145 = objA145 + objB145
print(result145)
Value: 436
# Cell 146 - Operator Overloading Example
class Overload146:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload146(self.num + other.num + 146)
def __str__(self):
return f"Value: {self.num}"
objA146 = Overload146(146)
objB146 = Overload146(147)
result146 = objA146 + objB146
print(result146)
Value: 439
# Cell 147 - Operator Overloading Example
class Overload147:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload147(self.num + other.num + 147)
def __str__(self):
return f"Value: {self.num}"
objA147 = Overload147(147)
objB147 = Overload147(148)
result147 = objA147 + objB147
print(result147)
Value: 442
# Cell 148 - Operator Overloading Example
class Overload148:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload148(self.num + other.num + 148)
def __str__(self):
return f"Value: {self.num}"
objA148 = Overload148(148)
objB148 = Overload148(149)
result148 = objA148 + objB148
print(result148)
Value: 445
# Cell 149 - Operator Overloading Example
class Overload149:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload149(self.num + other.num + 149)
def __str__(self):
return f"Value: {self.num}"
objA149 = Overload149(149)
objB149 = Overload149(150)
result149 = objA149 + objB149
print(result149)
Value: 448
# Cell 150 - Operator Overloading Example
class Overload150:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload150(self.num + other.num + 150)
def __str__(self):
return f"Value: {self.num}"
objA150 = Overload150(150)
objB150 = Overload150(151)
result150 = objA150 + objB150
print(result150)
Value: 451
# Cell 151 - Operator Overloading Example
class Overload151:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload151(self.num + other.num + 151)
def __str__(self):
return f"Value: {self.num}"
objA151 = Overload151(151)
objB151 = Overload151(152)
result151 = objA151 + objB151
print(result151)
Value: 454
# Cell 152 - Operator Overloading Example
class Overload152:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload152(self.num + other.num + 152)
def __str__(self):
return f"Value: {self.num}"
objA152 = Overload152(152)
objB152 = Overload152(153)
result152 = objA152 + objB152
print(result152)
Value: 457
# Cell 153 - Operator Overloading Example
class Overload153:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload153(self.num + other.num + 153)
def __str__(self):
return f"Value: {self.num}"
objA153 = Overload153(153)
objB153 = Overload153(154)
result153 = objA153 + objB153
print(result153)
Value: 460
# Cell 154 - Operator Overloading Example
class Overload154:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload154(self.num + other.num + 154)
def __str__(self):
return f"Value: {self.num}"
objA154 = Overload154(154)
objB154 = Overload154(155)
result154 = objA154 + objB154
print(result154)
Value: 463
# Cell 155 - Operator Overloading Example
class Overload155:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload155(self.num + other.num + 155)
def __str__(self):
return f"Value: {self.num}"
objA155 = Overload155(155)
objB155 = Overload155(156)
result155 = objA155 + objB155
print(result155)
Value: 466
# Cell 156 - Operator Overloading Example
class Overload156:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload156(self.num + other.num + 156)
def __str__(self):
return f"Value: {self.num}"
objA156 = Overload156(156)
objB156 = Overload156(157)
result156 = objA156 + objB156
print(result156)
Value: 469
# Cell 157 - Operator Overloading Example
class Overload157:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload157(self.num + other.num + 157)
def __str__(self):
return f"Value: {self.num}"
objA157 = Overload157(157)
objB157 = Overload157(158)
result157 = objA157 + objB157
print(result157)
Value: 472
# Cell 158 - Operator Overloading Example
class Overload158:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload158(self.num + other.num + 158)
def __str__(self):
return f"Value: {self.num}"
objA158 = Overload158(158)
objB158 = Overload158(159)
result158 = objA158 + objB158
print(result158)
Value: 475
# Cell 159 - Operator Overloading Example
class Overload159:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload159(self.num + other.num + 159)
def __str__(self):
return f"Value: {self.num}"
objA159 = Overload159(159)
objB159 = Overload159(160)
result159 = objA159 + objB159
print(result159)
Value: 478
# Cell 160 - Operator Overloading Example
class Overload160:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload160(self.num + other.num + 160)
def __str__(self):
return f"Value: {self.num}"
objA160 = Overload160(160)
objB160 = Overload160(161)
result160 = objA160 + objB160
print(result160)
Value: 481
# Cell 161 - Operator Overloading Example
class Overload161:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload161(self.num + other.num + 161)
def __str__(self):
return f"Value: {self.num}"
objA161 = Overload161(161)
objB161 = Overload161(162)
result161 = objA161 + objB161
print(result161)
Value: 484
# Cell 162 - Operator Overloading Example
class Overload162:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload162(self.num + other.num + 162)
def __str__(self):
return f"Value: {self.num}"
objA162 = Overload162(162)
objB162 = Overload162(163)
result162 = objA162 + objB162
print(result162)
Value: 487
# Cell 163 - Operator Overloading Example
class Overload163:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload163(self.num + other.num + 163)
def __str__(self):
return f"Value: {self.num}"
objA163 = Overload163(163)
objB163 = Overload163(164)
result163 = objA163 + objB163
print(result163)
Value: 490
# Cell 164 - Operator Overloading Example
class Overload164:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload164(self.num + other.num + 164)
def __str__(self):
return f"Value: {self.num}"
objA164 = Overload164(164)
objB164 = Overload164(165)
result164 = objA164 + objB164
print(result164)
Value: 493
# Cell 165 - Operator Overloading Example
class Overload165:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload165(self.num + other.num + 165)
def __str__(self):
return f"Value: {self.num}"
objA165 = Overload165(165)
objB165 = Overload165(166)
result165 = objA165 + objB165
print(result165)
Value: 496
# Cell 166 - Operator Overloading Example
class Overload166:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload166(self.num + other.num + 166)
def __str__(self):
return f"Value: {self.num}"
objA166 = Overload166(166)
objB166 = Overload166(167)
result166 = objA166 + objB166
print(result166)
Value: 499
# Cell 167 - Operator Overloading Example
class Overload167:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload167(self.num + other.num + 167)
def __str__(self):
return f"Value: {self.num}"
objA167 = Overload167(167)
objB167 = Overload167(168)
result167 = objA167 + objB167
print(result167)
Value: 502
# Cell 168 - Operator Overloading Example
class Overload168:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload168(self.num + other.num + 168)
def __str__(self):
return f"Value: {self.num}"
objA168 = Overload168(168)
objB168 = Overload168(169)
result168 = objA168 + objB168
print(result168)
Value: 505
# Cell 169 - Operator Overloading Example
class Overload169:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload169(self.num + other.num + 169)
def __str__(self):
return f"Value: {self.num}"
objA169 = Overload169(169)
objB169 = Overload169(170)
result169 = objA169 + objB169
print(result169)
Value: 508
# Cell 170 - Operator Overloading Example
class Overload170:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload170(self.num + other.num + 170)
def __str__(self):
return f"Value: {self.num}"
objA170 = Overload170(170)
objB170 = Overload170(171)
result170 = objA170 + objB170
print(result170)
Value: 511
# Cell 171 - Operator Overloading Example
class Overload171:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload171(self.num + other.num + 171)
def __str__(self):
return f"Value: {self.num}"
objA171 = Overload171(171)
objB171 = Overload171(172)
result171 = objA171 + objB171
print(result171)
Value: 514
# Cell 172 - Operator Overloading Example
class Overload172:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload172(self.num + other.num + 172)
def __str__(self):
return f"Value: {self.num}"
objA172 = Overload172(172)
objB172 = Overload172(173)
result172 = objA172 + objB172
print(result172)
Value: 517
# Cell 173 - Operator Overloading Example
class Overload173:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload173(self.num + other.num + 173)
def __str__(self):
return f"Value: {self.num}"
objA173 = Overload173(173)
objB173 = Overload173(174)
result173 = objA173 + objB173
print(result173)
Value: 520
# Cell 174 - Operator Overloading Example
class Overload174:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload174(self.num + other.num + 174)
def __str__(self):
return f"Value: {self.num}"
objA174 = Overload174(174)
objB174 = Overload174(175)
result174 = objA174 + objB174
print(result174)
Value: 523
# Cell 175 - Operator Overloading Example
class Overload175:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload175(self.num + other.num + 175)
def __str__(self):
return f"Value: {self.num}"
objA175 = Overload175(175)
objB175 = Overload175(176)
result175 = objA175 + objB175
print(result175)
Value: 526
# Cell 176 - Operator Overloading Example
class Overload176:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload176(self.num + other.num + 176)
def __str__(self):
return f"Value: {self.num}"
objA176 = Overload176(176)
objB176 = Overload176(177)
result176 = objA176 + objB176
print(result176)
Value: 529
# Cell 177 - Operator Overloading Example
class Overload177:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload177(self.num + other.num + 177)
def __str__(self):
return f"Value: {self.num}"
objA177 = Overload177(177)
objB177 = Overload177(178)
result177 = objA177 + objB177
print(result177)
Value: 532
# Cell 178 - Operator Overloading Example
class Overload178:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload178(self.num + other.num + 178)
def __str__(self):
return f"Value: {self.num}"
objA178 = Overload178(178)
objB178 = Overload178(179)
result178 = objA178 + objB178
print(result178)
Value: 535
# Cell 179 - Operator Overloading Example
class Overload179:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload179(self.num + other.num + 179)
def __str__(self):
return f"Value: {self.num}"
objA179 = Overload179(179)
objB179 = Overload179(180)
result179 = objA179 + objB179
print(result179)
Value: 538
# Cell 180 - Operator Overloading Example
class Overload180:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload180(self.num + other.num + 180)
def __str__(self):
return f"Value: {self.num}"
objA180 = Overload180(180)
objB180 = Overload180(181)
result180 = objA180 + objB180
print(result180)
Value: 541
# Cell 181 - Operator Overloading Example
class Overload181:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload181(self.num + other.num + 181)
def __str__(self):
return f"Value: {self.num}"
objA181 = Overload181(181)
objB181 = Overload181(182)
result181 = objA181 + objB181
print(result181)
Value: 544
# Cell 182 - Operator Overloading Example
class Overload182:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload182(self.num + other.num + 182)
def __str__(self):
return f"Value: {self.num}"
objA182 = Overload182(182)
objB182 = Overload182(183)
result182 = objA182 + objB182
print(result182)
Value: 547
# Cell 183 - Operator Overloading Example
class Overload183:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload183(self.num + other.num + 183)
def __str__(self):
return f"Value: {self.num}"
objA183 = Overload183(183)
objB183 = Overload183(184)
result183 = objA183 + objB183
print(result183)
Value: 550
# Cell 184 - Operator Overloading Example
class Overload184:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload184(self.num + other.num + 184)
def __str__(self):
return f"Value: {self.num}"
objA184 = Overload184(184)
objB184 = Overload184(185)
result184 = objA184 + objB184
print(result184)
Value: 553
# Cell 185 - Operator Overloading Example
class Overload185:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload185(self.num + other.num + 185)
def __str__(self):
return f"Value: {self.num}"
objA185 = Overload185(185)
objB185 = Overload185(186)
result185 = objA185 + objB185
print(result185)
Value: 556
# Cell 186 - Operator Overloading Example
class Overload186:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload186(self.num + other.num + 186)
def __str__(self):
return f"Value: {self.num}"
objA186 = Overload186(186)
objB186 = Overload186(187)
result186 = objA186 + objB186
print(result186)
Value: 559
# Cell 187 - Operator Overloading Example
class Overload187:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload187(self.num + other.num + 187)
def __str__(self):
return f"Value: {self.num}"
objA187 = Overload187(187)
objB187 = Overload187(188)
result187 = objA187 + objB187
print(result187)
Value: 562
# Cell 188 - Operator Overloading Example
class Overload188:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload188(self.num + other.num + 188)
def __str__(self):
return f"Value: {self.num}"
objA188 = Overload188(188)
objB188 = Overload188(189)
result188 = objA188 + objB188
print(result188)
Value: 565
# Cell 189 - Operator Overloading Example
class Overload189:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload189(self.num + other.num + 189)
def __str__(self):
return f"Value: {self.num}"
objA189 = Overload189(189)
objB189 = Overload189(190)
result189 = objA189 + objB189
print(result189)
Value: 568
# Cell 190 - Operator Overloading Example
class Overload190:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload190(self.num + other.num + 190)
def __str__(self):
return f"Value: {self.num}"
objA190 = Overload190(190)
objB190 = Overload190(191)
result190 = objA190 + objB190
print(result190)
Value: 571
# Cell 191 - Operator Overloading Example
class Overload191:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload191(self.num + other.num + 191)
def __str__(self):
return f"Value: {self.num}"
objA191 = Overload191(191)
objB191 = Overload191(192)
result191 = objA191 + objB191
print(result191)
Value: 574
# Cell 192 - Operator Overloading Example
class Overload192:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload192(self.num + other.num + 192)
def __str__(self):
return f"Value: {self.num}"
objA192 = Overload192(192)
objB192 = Overload192(193)
result192 = objA192 + objB192
print(result192)
Value: 577
# Cell 193 - Operator Overloading Example
class Overload193:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload193(self.num + other.num + 193)
def __str__(self):
return f"Value: {self.num}"
objA193 = Overload193(193)
objB193 = Overload193(194)
result193 = objA193 + objB193
print(result193)
Value: 580
# Cell 194 - Operator Overloading Example
class Overload194:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload194(self.num + other.num + 194)
def __str__(self):
return f"Value: {self.num}"
objA194 = Overload194(194)
objB194 = Overload194(195)
result194 = objA194 + objB194
print(result194)
Value: 583
# Cell 195 - Operator Overloading Example
class Overload195:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload195(self.num + other.num + 195)
def __str__(self):
return f"Value: {self.num}"
objA195 = Overload195(195)
objB195 = Overload195(196)
result195 = objA195 + objB195
print(result195)
Value: 586
# Cell 196 - Operator Overloading Example
class Overload196:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload196(self.num + other.num + 196)
def __str__(self):
return f"Value: {self.num}"
objA196 = Overload196(196)
objB196 = Overload196(197)
result196 = objA196 + objB196
print(result196)
Value: 589
# Cell 197 - Operator Overloading Example
class Overload197:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload197(self.num + other.num + 197)
def __str__(self):
return f"Value: {self.num}"
objA197 = Overload197(197)
objB197 = Overload197(198)
result197 = objA197 + objB197
print(result197)
Value: 592
# Cell 198 - Operator Overloading Example
class Overload198:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload198(self.num + other.num + 198)
def __str__(self):
return f"Value: {self.num}"
objA198 = Overload198(198)
objB198 = Overload198(199)
result198 = objA198 + objB198
print(result198)
Value: 595
# Cell 199 - Operator Overloading Example
class Overload199:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload199(self.num + other.num + 199)
def __str__(self):
return f"Value: {self.num}"
objA199 = Overload199(199)
objB199 = Overload199(200)
result199 = objA199 + objB199
print(result199)
Value: 598
# Cell 200 - Operator Overloading Example
class Overload200:
def __init__(self, num):
self.num = num
def __add__(self, other):
return Overload200(self.num + other.num + 200)
def __str__(self):
return f"Value: {self.num}"
objA200 = Overload200(200)
objB200 = Overload200(201)
result200 = objA200 + objB200
print(result200)
Value: 601
Score: 200
Category: basics