Slots

1"""Memory savings with __slots__"""23# Memory comparison4print("Memory comparison:")56import sys78class WithoutSlots:9    def __init__(self, x, y, z):10        self.x = x11        self.y = y12        self.z = z1314class WithSlots:15    __slots__ = ['x', 'y', 'z']16    17    def __init__(self, x, y, z):18        self.x = x19        self.y = y20        self.z = z2122# Create single instances23obj_no_slots = WithoutSlots(1, 2, 3)24obj_with_slots = WithSlots(1, 2, 3)⋯

⋯8class WithoutSlots:9    def __init__(self⟨WithoutSlots A⟩, x1, y2, z3):10        self.x→ 1 = x111        self.y→ 2 = y212        self.z→ 3 = z3⋯

⋯22# Create single instances23obj_no_slots→ ⟨WithoutSlots A⟩ = WithoutSlots(1, 2, 3)24obj_with_slots = WithSlots(1, 2, 3)⋯

⋯17def __init__(self⟨WithSlots L⟩, x1, y2, z3):18    self.x→ 1 = x119    self.y→ 2 = y220    self.z→ 3 = z3⋯

⋯23obj_no_slots = WithoutSlots(1, 2, 3)24obj_with_slots→ ⟨WithSlots L⟩ = WithSlots(1, 2, 3)2526# Get sizes27size_no_slots→ 344 = sys<module 'sys' (built-in)>.getsizeof(obj_no_slots⟨WithoutSlots A⟩) + sys.getsizeof(obj_no_slots.__dict__{'x': 1, 'y': 2, 'z': 3})28size_with_slots→ 56 = sys<module 'sys' (built-in)>.getsizeof(obj_with_slots⟨WithSlots L⟩)2930print(f"Without __slots__: {size_no_slots344} bytes")31print(f"With __slots__: {size_with_slots56} bytes")32print(f"Savings: {size_no_slots344 - size_with_slots56} bytes ({100 * (1 - size_with_slots/size_no_slots):.1f}%)")3334# Many instances35print("\nMany instances:")3637# Create many instances38count→ 100 = 1003940no_slots_list = [WithoutSlots(i, i+1, i+2) for i in range(count100)]41with_slots_list = [WithSlots(i, i+1, i+2) for i in range(count)]⋯

⋯40no_slots_list→ [⟨WithoutSlots B⟩, ⟨WithoutSlots C⟩, ⟨WithoutSlots D⟩, ⟨WithoutSlots E⟩, ⟨WithoutSlots F⟩, ⟨WithoutSlots G⟩, ⟨WithoutSlots H⟩, ⟨WithoutSlots I⟩, ⟨WithoutSlots W⟩, ⟨WithoutSlots X⟩, ⟨WithoutSlots Y⟩, ⟨WithoutSlots Z⟩, ⟨WithoutSlots AA⟩, ⟨WithoutSlots AB⟩, ⟨WithoutSlots AC⟩, ⟨WithoutSlots AD⟩, ⟨WithoutSlots AE⟩, ⟨WithoutSlots AF⟩, ⟨WithoutSlots AG⟩, ⟨WithoutSlots AH⟩, ⟨WithoutSlots AI⟩, ⟨WithoutSlots AJ⟩, ⟨WithoutSlots AK⟩, ⟨WithoutSlots AL⟩, ⟨WithoutSlots AM⟩, ⟨WithoutSlots AN⟩, ⟨WithoutSlots AO⟩, ⟨WithoutSlots AP⟩, ⟨WithoutSlots AQ⟩, ⟨WithoutSlots AR⟩, ⟨WithoutSlots AS⟩, ⟨WithoutSlots AT⟩, ⟨WithoutSlots AU⟩, ⟨WithoutSlots AV⟩, ⟨WithoutSlots AW⟩, ⟨WithoutSlots AX⟩, ⟨WithoutSlots AY⟩, ⟨WithoutSlots AZ⟩, ⟨WithoutSlots BA⟩, ⟨WithoutSlots BB⟩, ⟨WithoutSlots BC⟩, ⟨WithoutSlots BD⟩, ⟨WithoutSlots BE⟩, ⟨WithoutSlots BF⟩, ⟨WithoutSlots BG⟩, ⟨WithoutSlots BH⟩, ⟨WithoutSlots BI⟩, ⟨WithoutSlots BJ⟩, ⟨WithoutSlots BK⟩, ⟨WithoutSlots BL⟩, ⟨WithoutSlots BM⟩, ⟨WithoutSlots BN⟩, ⟨WithoutSlots BO⟩, ⟨WithoutSlots BP⟩, ⟨WithoutSlots BQ⟩, ⟨WithoutSlots BR⟩, ⟨WithoutSlots BS⟩, ⟨WithoutSlots BT⟩, ⟨WithoutSlots BU⟩, ⟨WithoutSlots BV⟩, ⟨WithoutSlots BW⟩, ⟨WithoutSlots BX⟩, ⟨WithoutSlots BY⟩, ⟨WithoutSlots BZ⟩, ⟨WithoutSlots CA⟩, ⟨WithoutSlots CB⟩, ⟨WithoutSlots CC⟩, ⟨WithoutSlots CD⟩, ⟨WithoutSlots CE⟩, ⟨WithoutSlots CF⟩, ⟨WithoutSlots CG⟩, ⟨WithoutSlots CH⟩, ⟨WithoutSlots CI⟩, ⟨WithoutSlots CJ⟩, ⟨WithoutSlots CK⟩, ⟨WithoutSlots CL⟩, ⟨WithoutSlots CM⟩, ⟨WithoutSlots CN⟩, ⟨WithoutSlots CO⟩, ⟨WithoutSlots CP⟩, ⟨WithoutSlots CQ⟩, ⟨WithoutSlots CR⟩, ⟨WithoutSlots CS⟩, ⟨WithoutSlots CT⟩, ⟨WithoutSlots CU⟩, ⟨WithoutSlots CV⟩, ⟨WithoutSlots CW⟩, ⟨WithoutSlots CX⟩, ⟨WithoutSlots CY⟩, ⟨WithoutSlots CZ⟩, ⟨WithoutSlots DA⟩, ⟨WithoutSlots DB⟩, ⟨WithoutSlots DC⟩, ⟨WithoutSlots DD⟩, ⟨WithoutSlots DE⟩, ⟨WithoutSlots DF⟩, ⟨WithoutSlots DG⟩, ⟨WithoutSlots DH⟩, ⟨WithoutSlots J⟩, ⟨WithoutSlots K⟩] = [WithoutSlots(i, i+1, i+2) for i in range(count100)]41with_slots_list = [WithSlots(i, i+1, i+2) for i in range(count100)]⋯

⋯40no_slots_list = [WithoutSlots(i, i+1, i+2) for i in range(count)]41with_slots_list→ [⟨WithSlots M⟩, ⟨WithSlots N⟩, ⟨WithSlots O⟩, ⟨WithSlots P⟩, ⟨WithSlots Q⟩, ⟨WithSlots R⟩, ⟨WithSlots S⟩, ⟨WithSlots T⟩, ⟨WithSlots DI⟩, ⟨WithSlots DJ⟩, ⟨WithSlots DK⟩, ⟨WithSlots DL⟩, ⟨WithSlots DM⟩, ⟨WithSlots DN⟩, ⟨WithSlots DO⟩, ⟨WithSlots DP⟩, ⟨WithSlots DQ⟩, ⟨WithSlots DR⟩, ⟨WithSlots DS⟩, ⟨WithSlots DT⟩, ⟨WithSlots DU⟩, ⟨WithSlots DV⟩, ⟨WithSlots DW⟩, ⟨WithSlots DX⟩, ⟨WithSlots DY⟩, ⟨WithSlots DZ⟩, ⟨WithSlots EA⟩, ⟨WithSlots EB⟩, ⟨WithSlots EC⟩, ⟨WithSlots ED⟩, ⟨WithSlots EE⟩, ⟨WithSlots EF⟩, ⟨WithSlots EG⟩, ⟨WithSlots EH⟩, ⟨WithSlots EI⟩, ⟨WithSlots EJ⟩, ⟨WithSlots EK⟩, ⟨WithSlots EL⟩, ⟨WithSlots EM⟩, ⟨WithSlots EN⟩, ⟨WithSlots EO⟩, ⟨WithSlots EP⟩, ⟨WithSlots EQ⟩, ⟨WithSlots ER⟩, ⟨WithSlots ES⟩, ⟨WithSlots ET⟩, ⟨WithSlots EU⟩, ⟨WithSlots EV⟩, ⟨WithSlots EW⟩, ⟨WithSlots EX⟩, ⟨WithSlots EY⟩, ⟨WithSlots EZ⟩, ⟨WithSlots FA⟩, ⟨WithSlots FB⟩, ⟨WithSlots FC⟩, ⟨WithSlots FD⟩, ⟨WithSlots FE⟩, ⟨WithSlots FF⟩, ⟨WithSlots FG⟩, ⟨WithSlots FH⟩, ⟨WithSlots FI⟩, ⟨WithSlots FJ⟩, ⟨WithSlots FK⟩, ⟨WithSlots FL⟩, ⟨WithSlots FM⟩, ⟨WithSlots FN⟩, ⟨WithSlots FO⟩, ⟨WithSlots FP⟩, ⟨WithSlots FQ⟩, ⟨WithSlots FR⟩, ⟨WithSlots FS⟩, ⟨WithSlots FT⟩, ⟨WithSlots FU⟩, ⟨WithSlots FV⟩, ⟨WithSlots FW⟩, ⟨WithSlots FX⟩, ⟨WithSlots FY⟩, ⟨WithSlots FZ⟩, ⟨WithSlots GA⟩, ⟨WithSlots GB⟩, ⟨WithSlots GC⟩, ⟨WithSlots GD⟩, ⟨WithSlots GE⟩, ⟨WithSlots GF⟩, ⟨WithSlots GG⟩, ⟨WithSlots GH⟩, ⟨WithSlots GI⟩, ⟨WithSlots GJ⟩, ⟨WithSlots GK⟩, ⟨WithSlots GL⟩, ⟨WithSlots GM⟩, ⟨WithSlots GN⟩, ⟨WithSlots GO⟩, ⟨WithSlots GP⟩, ⟨WithSlots GQ⟩, ⟨WithSlots GR⟩, ⟨WithSlots GS⟩, ⟨WithSlots GT⟩, ⟨WithSlots U⟩, ⟨WithSlots V⟩] = [WithSlots(i, i+1, i+2) for i in range(count100)]4243# Estimate total size44total_no_slots→ 14400.0 = sum(sys<module 'sys' (built-in)>.getsizeof(obj) + sys.getsizeof(obj.__dict__(empty)) for obj in no_slots_list[:100][⟨WithoutSlots B⟩, ⟨WithoutSlots C⟩, ⟨WithoutSlots D⟩, ⟨WithoutSlots E⟩, ⟨WithoutSlots F⟩, ⟨WithoutSlots G⟩, ⟨WithoutSlots H⟩, ⟨WithoutSlots I⟩, ⟨WithoutSlots W⟩, ⟨WithoutSlots X⟩, ⟨WithoutSlots Y⟩, ⟨WithoutSlots Z⟩, ⟨WithoutSlots AA⟩, ⟨WithoutSlots AB⟩, ⟨WithoutSlots AC⟩, ⟨WithoutSlots AD⟩, ⟨WithoutSlots AE⟩, ⟨WithoutSlots AF⟩, ⟨WithoutSlots AG⟩, ⟨WithoutSlots AH⟩, ⟨WithoutSlots AI⟩, ⟨WithoutSlots AJ⟩, ⟨WithoutSlots AK⟩, ⟨WithoutSlots AL⟩, ⟨WithoutSlots AM⟩, ⟨WithoutSlots AN⟩, ⟨WithoutSlots AO⟩, ⟨WithoutSlots AP⟩, ⟨WithoutSlots AQ⟩, ⟨WithoutSlots AR⟩, ⟨WithoutSlots AS⟩, ⟨WithoutSlots AT⟩, ⟨WithoutSlots AU⟩, ⟨WithoutSlots AV⟩, ⟨WithoutSlots AW⟩, ⟨WithoutSlots AX⟩, ⟨WithoutSlots AY⟩, ⟨WithoutSlots AZ⟩, ⟨WithoutSlots BA⟩, ⟨WithoutSlots BB⟩, ⟨WithoutSlots BC⟩, ⟨WithoutSlots BD⟩, ⟨WithoutSlots BE⟩, ⟨WithoutSlots BF⟩, ⟨WithoutSlots BG⟩, ⟨WithoutSlots BH⟩, ⟨WithoutSlots BI⟩, ⟨WithoutSlots BJ⟩, ⟨WithoutSlots BK⟩, ⟨WithoutSlots BL⟩, ⟨WithoutSlots BM⟩, ⟨WithoutSlots BN⟩, ⟨WithoutSlots BO⟩, ⟨WithoutSlots BP⟩, ⟨WithoutSlots BQ⟩, ⟨WithoutSlots BR⟩, ⟨WithoutSlots BS⟩, ⟨WithoutSlots BT⟩, ⟨WithoutSlots BU⟩, ⟨WithoutSlots BV⟩, ⟨WithoutSlots BW⟩, ⟨WithoutSlots BX⟩, ⟨WithoutSlots BY⟩, ⟨WithoutSlots BZ⟩, ⟨WithoutSlots CA⟩, ⟨WithoutSlots CB⟩, ⟨WithoutSlots CC⟩, ⟨WithoutSlots CD⟩, ⟨WithoutSlots CE⟩, ⟨WithoutSlots CF⟩, ⟨WithoutSlots CG⟩, ⟨WithoutSlots CH⟩, ⟨WithoutSlots CI⟩, ⟨WithoutSlots CJ⟩, ⟨WithoutSlots CK⟩, ⟨WithoutSlots CL⟩, ⟨WithoutSlots CM⟩, ⟨WithoutSlots CN⟩, ⟨WithoutSlots CO⟩, ⟨WithoutSlots CP⟩, ⟨WithoutSlots CQ⟩, ⟨WithoutSlots CR⟩, ⟨WithoutSlots CS⟩, ⟨WithoutSlots CT⟩, ⟨WithoutSlots CU⟩, ⟨WithoutSlots CV⟩, ⟨WithoutSlots CW⟩, ⟨WithoutSlots CX⟩, ⟨WithoutSlots CY⟩, ⟨WithoutSlots CZ⟩, ⟨WithoutSlots DA⟩, ⟨WithoutSlots DB⟩, ⟨WithoutSlots DC⟩, ⟨WithoutSlots DD⟩, ⟨WithoutSlots DE⟩, ⟨WithoutSlots DF⟩, ⟨WithoutSlots DG⟩, ⟨WithoutSlots DH⟩, ⟨WithoutSlots J⟩, ⟨WithoutSlots K⟩]) / 100 * count10045total_with_slots→ 5600.0 = sum(sys<module 'sys' (built-in)>.getsizeof(obj) for obj in with_slots_list[:100][⟨WithSlots M⟩, ⟨WithSlots N⟩, ⟨WithSlots O⟩, ⟨WithSlots P⟩, ⟨WithSlots Q⟩, ⟨WithSlots R⟩, ⟨WithSlots S⟩, ⟨WithSlots T⟩, ⟨WithSlots DI⟩, ⟨WithSlots DJ⟩, ⟨WithSlots DK⟩, ⟨WithSlots DL⟩, ⟨WithSlots DM⟩, ⟨WithSlots DN⟩, ⟨WithSlots DO⟩, ⟨WithSlots DP⟩, ⟨WithSlots DQ⟩, ⟨WithSlots DR⟩, ⟨WithSlots DS⟩, ⟨WithSlots DT⟩, ⟨WithSlots DU⟩, ⟨WithSlots DV⟩, ⟨WithSlots DW⟩, ⟨WithSlots DX⟩, ⟨WithSlots DY⟩, ⟨WithSlots DZ⟩, ⟨WithSlots EA⟩, ⟨WithSlots EB⟩, ⟨WithSlots EC⟩, ⟨WithSlots ED⟩, ⟨WithSlots EE⟩, ⟨WithSlots EF⟩, ⟨WithSlots EG⟩, ⟨WithSlots EH⟩, ⟨WithSlots EI⟩, ⟨WithSlots EJ⟩, ⟨WithSlots EK⟩, ⟨WithSlots EL⟩, ⟨WithSlots EM⟩, ⟨WithSlots EN⟩, ⟨WithSlots EO⟩, ⟨WithSlots EP⟩, ⟨WithSlots EQ⟩, ⟨WithSlots ER⟩, ⟨WithSlots ES⟩, ⟨WithSlots ET⟩, ⟨WithSlots EU⟩, ⟨WithSlots EV⟩, ⟨WithSlots EW⟩, ⟨WithSlots EX⟩, ⟨WithSlots EY⟩, ⟨WithSlots EZ⟩, ⟨WithSlots FA⟩, ⟨WithSlots FB⟩, ⟨WithSlots FC⟩, ⟨WithSlots FD⟩, ⟨WithSlots FE⟩, ⟨WithSlots FF⟩, ⟨WithSlots FG⟩, ⟨WithSlots FH⟩, ⟨WithSlots FI⟩, ⟨WithSlots FJ⟩, ⟨WithSlots FK⟩, ⟨WithSlots FL⟩, ⟨WithSlots FM⟩, ⟨WithSlots FN⟩, ⟨WithSlots FO⟩, ⟨WithSlots FP⟩, ⟨WithSlots FQ⟩, ⟨WithSlots FR⟩, ⟨WithSlots FS⟩, ⟨WithSlots FT⟩, ⟨WithSlots FU⟩, ⟨WithSlots FV⟩, ⟨WithSlots FW⟩, ⟨WithSlots FX⟩, ⟨WithSlots FY⟩, ⟨WithSlots FZ⟩, ⟨WithSlots GA⟩, ⟨WithSlots GB⟩, ⟨WithSlots GC⟩, ⟨WithSlots GD⟩, ⟨WithSlots GE⟩, ⟨WithSlots GF⟩, ⟨WithSlots GG⟩, ⟨WithSlots GH⟩, ⟨WithSlots GI⟩, ⟨WithSlots GJ⟩, ⟨WithSlots GK⟩, ⟨WithSlots GL⟩, ⟨WithSlots GM⟩, ⟨WithSlots GN⟩, ⟨WithSlots GO⟩, ⟨WithSlots GP⟩, ⟨WithSlots GQ⟩, ⟨WithSlots GR⟩, ⟨WithSlots GS⟩, ⟨WithSlots GT⟩, ⟨WithSlots U⟩, ⟨WithSlots V⟩]) / 100 * count1004647print(f"{count100} instances:")48print(f"Without __slots__: ~{total_no_slots14400.0/1024:.1f} KB")49print(f"With __slots__: ~{total_with_slots5600.0/1024:.1f} KB")50print(f"Estimated savings: ~{(total_no_slots14400.0 - total_with_slots5600.0)/1024:.1f} KB")5152# Simple data class53print("\nSimple data class:")5455class Point:56    __slots__ = ['x', 'y']57    58    def __init__(self, x, y):59        self.x = x60        self.y = y6162# Create many points63points = [Point(i, i*2) for i in range(100)]⋯

⋯58def __init__(self⟨Point GU⟩, x0, y0):59    self.x→ 0 = x060    self.y→ 0 = y0⋯

⋯62# Create many points63points→ [⟨Point GU⟩, ⟨Point GV⟩, ⟨Point GW⟩, ⟨Point GX⟩, ⟨Point GY⟩, ⟨Point GZ⟩, ⟨Point HA⟩, ⟨Point HB⟩, ⟨Point HC⟩, ⟨Point HF⟩, ⟨Point HG⟩, ⟨Point HH⟩, ⟨Point HI⟩, ⟨Point HJ⟩, ⟨Point HK⟩, ⟨Point HL⟩, ⟨Point HM⟩, ⟨Point HN⟩, ⟨Point HO⟩, ⟨Point HP⟩, ⟨Point HQ⟩, ⟨Point HR⟩, ⟨Point HS⟩, ⟨Point HT⟩, ⟨Point HU⟩, ⟨Point HV⟩, ⟨Point HW⟩, ⟨Point HX⟩, ⟨Point HY⟩, ⟨Point HZ⟩, ⟨Point IA⟩, ⟨Point IB⟩, ⟨Point IC⟩, ⟨Point ID⟩, ⟨Point IE⟩, ⟨Point IF⟩, ⟨Point IG⟩, ⟨Point IH⟩, ⟨Point II⟩, ⟨Point IJ⟩, ⟨Point IK⟩, ⟨Point IL⟩, ⟨Point IM⟩, ⟨Point IN⟩, ⟨Point IO⟩, ⟨Point IP⟩, ⟨Point IQ⟩, ⟨Point IR⟩, ⟨Point IS⟩, ⟨Point IT⟩, ⟨Point IU⟩, ⟨Point IV⟩, ⟨Point IW⟩, ⟨Point IX⟩, ⟨Point IY⟩, ⟨Point IZ⟩, ⟨Point JA⟩, ⟨Point JB⟩, ⟨Point JC⟩, ⟨Point JD⟩, ⟨Point JE⟩, ⟨Point JF⟩, ⟨Point JG⟩, ⟨Point JH⟩, ⟨Point JI⟩, ⟨Point JJ⟩, ⟨Point JK⟩, ⟨Point JL⟩, ⟨Point JM⟩, ⟨Point JN⟩, ⟨Point JO⟩, ⟨Point JP⟩, ⟨Point JQ⟩, ⟨Point JR⟩, ⟨Point JS⟩, ⟨Point JT⟩, ⟨Point JU⟩, ⟨Point JV⟩, ⟨Point JW⟩, ⟨Point JX⟩, ⟨Point JY⟩, ⟨Point JZ⟩, ⟨Point KA⟩, ⟨Point KB⟩, ⟨Point KC⟩, ⟨Point KD⟩, ⟨Point KE⟩, ⟨Point KF⟩, ⟨Point KG⟩, ⟨Point KH⟩, ⟨Point KI⟩, ⟨Point KJ⟩, ⟨Point KK⟩, ⟨Point KL⟩, ⟨Point KM⟩, ⟨Point KN⟩, ⟨Point KO⟩, ⟨Point KP⟩, ⟨Point HD⟩, ⟨Point HE⟩] = [Point(i, i*2) for i in range(100)]6465# Sample memory usage66sample_size→ 48 = sys<module 'sys' (built-in)>.getsizeof(points[0]⟨Point GU⟩)67print(f"Point with __slots__: {sample_size48} bytes each")68print(f"100 points: ~{sample_size48 * 100 / 1024:.1f} KB")6970# Complex object71print("\nComplex object:")7273class PersonNoSlots:74    def __init__(self, name, age, email, city):75        self.name = name76        self.age = age77        self.email = email78        self.city = city7980class PersonWithSlots:81    __slots__ = ['name', 'age', 'email', 'city']82    83    def __init__(self, name, age, email, city):84        self.name = name85        self.age = age86        self.email = email87        self.city = city8889p1 = PersonNoSlots("Alice", 30, "alice@example.com", "NYC")90p2 = PersonWithSlots("Alice", 30, "alice@example.com", "NYC")⋯

⋯73class PersonNoSlots:74    def __init__(self⟨PersonNoSlots KQ⟩, nameAlice, age30, emailalice@example.com, cityNYC):75        self.name→ Alice = nameAlice76        self.age→ 30 = age3077        self.email→ alice@example.com = emailalice@example.com78        self.city→ NYC = cityNYC⋯

⋯89p1→ ⟨PersonNoSlots KQ⟩ = PersonNoSlots("Alice", 30, "alice@example.com", "NYC")90p2 = PersonWithSlots("Alice", 30, "alice@example.com", "NYC")⋯

⋯83def __init__(self⟨PersonWithSlots KR⟩, nameAlice, age30, emailalice@example.com, cityNYC):84    self.name→ Alice = nameAlice85    self.age→ 30 = age3086    self.email→ alice@example.com = emailalice@example.com87    self.city→ NYC = cityNYC⋯

⋯89p1 = PersonNoSlots("Alice", 30, "alice@example.com", "NYC")90p2→ ⟨PersonWithSlots KR⟩ = PersonWithSlots("Alice", 30, "alice@example.com", "NYC")9192size1→ 344 = sys<module 'sys' (built-in)>.getsizeof(p1⟨PersonNoSlots KQ⟩) + sys.getsizeof(p1.__dict__{'name': 'Alice', 'age': 30, 'email': 'alice@example.com', 'city': 'NYC'})93size2→ 64 = sys<module 'sys' (built-in)>.getsizeof(p2⟨PersonWithSlots KR⟩)9495print(f"PersonNoSlots: {size1344} bytes")96print(f"PersonWithSlots: {size264} bytes")97print(f"Savings per instance: {size1344 - size264} bytes")9899# Large dataset100print("\nLarge dataset:")101102class Record:103    __slots__ = ['id', 'timestamp', 'value', 'status']104    105    def __init__(self, id, timestamp, value, status):106        self.id = id107        self.timestamp = timestamp108        self.value = value109        self.status = status110111# Simulate large dataset112dataset_size→ 10000 = 10000113print(f"Creating {dataset_size10000} records...")114115# Estimate memory (based on sample)116sample = Record(1, 1234567890, 42.5, "active")117record_size = sys.getsizeof(sample)⋯

⋯105def __init__(self⟨Record KS⟩, id1, timestamp1234567890, value42.5, statusactive):106    self.id→ 1 = id1107    self.timestamp→ 1234567890 = timestamp1234567890108    self.value→ 42.5 = value42.5109    self.status→ active = statusactive⋯

⋯115# Estimate memory (based on sample)116sample→ ⟨Record KS⟩ = Record(1, 1234567890, 42.5, "active")117record_size→ 64 = sys<module 'sys' (built-in)>.getsizeof(sample⟨Record KS⟩)118119print(f"Size per record: {record_size64} bytes")120print(f"Total for {dataset_size10000} records: ~{record_size64 * dataset_size / 1024 / 1024:.1f} MB")121122# Time series data123print("\nTime series data:")124125class DataPoint:126    __slots__ = ['timestamp', 'value']127    128    def __init__(self, timestamp, value):129        self.timestamp = timestamp130        self.value = value131132# Simulate 1 year of per-minute data133minutes_per_year→ 525600 = 365 * 24 * 60134point_size = sys<module 'sys' (built-in)>.getsizeof(DataPoint(0, 0.0))⋯

⋯128def __init__(self⟨DataPoint KT⟩, timestamp0, value0.0):129    self.timestamp→ 0 = timestamp0130    self.value→ 0.0 = value0.0⋯

⋯133minutes_per_year = 365 * 24 * 60134point_size→ 48 = sys<module 'sys' (built-in)>.getsizeof(DataPoint(0, 0.0))135136print(f"Data point size: {point_size48} bytes")137print(f"1 year (minute resolution): ~{point_size48 * minutes_per_year525600 / 1024 / 1024:.1f} MB")138139# Practical comparison140print("\nPractical comparison:")141142# Coordinates for game143class CoordNoSlots:144    def __init__(self, x, y, z):145        self.x = x146        self.y = y147        self.z = z148149class CoordWithSlots:150    __slots__ = ['x', 'y', 'z']151    152    def __init__(self, x, y, z):153        self.x = x154        self.y = y155        self.z = z156157# Simulate game world with many entities158entity_count→ 1000 = 1000159160# Sample sizes161no_slots = CoordNoSlots(0, 0, 0)162with_slots = CoordWithSlots(0, 0, 0)⋯

⋯143class CoordNoSlots:144    def __init__(self⟨CoordNoSlots KU⟩, x0, y0, z0):145        self.x→ 0 = x0146        self.y→ 0 = y0147        self.z→ 0 = z0⋯

⋯160# Sample sizes161no_slots→ ⟨CoordNoSlots KU⟩ = CoordNoSlots(0, 0, 0)162with_slots = CoordWithSlots(0, 0, 0)⋯

⋯152def __init__(self⟨CoordWithSlots KV⟩, x0, y0, z0):153    self.x→ 0 = x0154    self.y→ 0 = y0155    self.z→ 0 = z0⋯

⋯161no_slots = CoordNoSlots(0, 0, 0)162with_slots→ ⟨CoordWithSlots KV⟩ = CoordWithSlots(0, 0, 0)163164size_no→ 344 = sys<module 'sys' (built-in)>.getsizeof(no_slots⟨CoordNoSlots KU⟩) + sys.getsizeof(no_slots.__dict__{'x': 0, 'y': 0, 'z': 0})165size_with→ 56 = sys<module 'sys' (built-in)>.getsizeof(with_slots⟨CoordWithSlots KV⟩)166167print(f"{entity_count1000} game entities:")168print(f"Without __slots__: ~{size_no344 * entity_count1000 / 1024:.1f} KB")169print(f"With __slots__: ~{size_with56 * entity_count1000 / 1024:.1f} KB")170print(f"Memory saved: ~{(size_no344 - size_with56) * entity_count1000 / 1024:.1f} KB")⋯

1"""No dynamic attributes with __slots__"""23# Dynamic attributes blocked4print("Dynamic attributes blocked:")56class User:7    __slots__ = ['name', 'email']8    9    def __init__(self, name, email):10        self.name = name11        self.email = email1213user = User("Alice", "alice@example.com")⋯

⋯9def __init__(self⟨User A⟩, nameAlice, emailalice@example.com):10    self.name→ Alice = nameAlice11    self.email→ alice@example.com = emailalice@example.com⋯

⋯13user→ ⟨User A⟩ = User("Alice", "alice@example.com")1415# Allowed attributes work16print(f"Name: {user.nameAlice}")17print(f"Email: {user.emailalice@example.com}")1819# Modifying allowed attributes works20user.name→ Alice Smith = "Alice Smith"21print(f"Updated name: {user.nameAlice Smith}")⋯

⋯25    user.age = 3026except AttributeError as e:27    print(f"Error adding 'age': {e'User' object has no attribute 'age'}")⋯

⋯30    user.city = "NYC"31except AttributeError as e:32    print(f"Error adding 'city': {e'User' object has no attribute 'city'}")⋯

⋯34# No __dict__35print("\nNo __dict__:")3637class NoDict:38    __slots__ = ['x', 'y']39    40    def __init__(self, x, y):41        self.x = x42        self.y = y4344obj = NoDict(10, 20)⋯

⋯40def __init__(self⟨NoDict B⟩, x10, y20):41    self.x→ 10 = x1042    self.y→ 20 = y20⋯

⋯44obj→ ⟨NoDict B⟩ = NoDict(10, 20)4546# __dict__ doesn't exist47print(f"Has __dict__: {hasattr(obj⟨NoDict B⟩, '__dict__')}")⋯

⋯49# Can't access __dict__50try:51    print(obj.__dict__(empty))52except AttributeError as e:⋯

⋯51    print(obj.__dict__)52except AttributeError as e:53    print(f"Error: {e'NoDict' object has no attribute '__dict__'}")⋯

⋯55# __slots__ is available56print(f"__slots__: {obj.__slots__['x', 'y']}")5758# Deleting attributes59print("\nDeleting attributes:")6061class Point:62    __slots__ = ['x', 'y']63    64    def __init__(self, x, y):65        self.x = x66        self.y = y6768p = Point(5, 10)69print(f"Point: ({p.x}, {p.y})")⋯

⋯64def __init__(self⟨Point C⟩, x5, y10):65    self.x→ 5 = x566    self.y→ 10 = y10⋯

⋯68p→ ⟨Point C⟩ = Point(5, 10)69print(f"Point: ({p.x5}, {p.y10})")7071# Can delete slotted attributes72del p.x73print(f"Has x: {hasattr(p⟨Point C⟩, 'x')}")⋯

⋯75# Accessing deleted attribute fails76try:77    print(p.x(empty))78except AttributeError as e:⋯

⋯77    print(p.x)78except AttributeError as e:79    print(f"Error: {e'Point' object has no attribute 'x'}")⋯

⋯81# Can reassign82p.x→ 15 = 1583print(f"Reassigned x: {p.x15}")8485# Class attributes still work86print("\nClass attributes still work:")8788class Config:89    __slots__ = ['name']90    91    # Class attributes are fine92    DEFAULT_TIMEOUT→ (empty) = 3093    VERSION→ (empty) = "1.0"94    95    def __init__(self, name):96        self.name = name9798config = Config("prod")99print(f"Instance name: {config.name}")⋯

⋯95def __init__(self⟨Config D⟩, nameprod):96    self.name→ prod = nameprod⋯

⋯98config→ ⟨Config D⟩ = Config("prod")99print(f"Instance name: {config.nameprod}")100print(f"Class DEFAULT_TIMEOUT: {config.DEFAULT_TIMEOUT30}")101print(f"Class VERSION: {config.VERSION1.0}")102103# Can modify class attributes104Config.VERSION→ 1.1 = "1.1"105print(f"Updated VERSION: {config.VERSION1.1}")106107# Methods still work108print("\nMethods still work:")109110class Rectangle:111    __slots__ = ['width', 'height']112    113    def __init__(self, width, height):114        self.width = width115        self.height = height116    117    def area(self):118        return self.width * self.height119    120    def perimeter(self):121        return 2 * (self.width + self.height)122123rect = Rectangle(10, 5)124print(f"Area: {rect.area()}")⋯

⋯113def __init__(self⟨Rectangle E⟩, width10, height5):114    self.width→ 10 = width10115    self.height→ 5 = height5⋯

⋯123rect→ ⟨Rectangle E⟩ = Rectangle(10, 5)124print(f"Area: {rect⟨Rectangle E⟩.area()}")125print(f"Perimeter: {rect.perimeter()}")⋯

⋯117def area(self⟨Rectangle E⟩):118    return self.width10 * self.height5⋯

⋯123rect = Rectangle(10, 5)124print(f"Area: {rect⟨Rectangle E⟩.area()}")125print(f"Perimeter: {rect⟨Rectangle E⟩.perimeter()}")⋯

⋯120def perimeter(self⟨Rectangle E⟩):121    return 2 * (self.width10 + self.height5)⋯

⋯124print(f"Area: {rect.area()}")125print(f"Perimeter: {rect⟨Rectangle E⟩.perimeter()}")126127# Properties work128print("\nProperties work:")129130class Temperature:131    __slots__ = ['_celsius']132    133    def __init__(self, celsius):134        self._celsius = celsius135    136    @property137    def celsius(self):138        return self._celsius139    140    @celsius.setter141    def celsius(self, value):142        self._celsius = value143    144    @property145    def fahrenheit(self):146        return self._celsius * 9/5 + 32147148temp = Temperature(25)149print(f"Celsius: {temp.celsius}")⋯

⋯133def __init__(self⟨Temperature F⟩, celsius25):134    self._celsius→ 25 = celsius25⋯

⋯148temp→ ⟨Temperature F⟩ = Temperature(25)149print(f"Celsius: {temp.celsius25}")150print(f"Fahrenheit: {temp.fahrenheit}")⋯

⋯136@property137def celsius(self⟨Temperature F⟩):138    return self._celsius25⋯

⋯148temp = Temperature(25)149print(f"Celsius: {temp.celsius25}")150print(f"Fahrenheit: {temp.fahrenheit77.0}")⋯

⋯144@property145def fahrenheit(self⟨Temperature F⟩):146    return self._celsius25 * 9/5 + 32⋯

⋯149print(f"Celsius: {temp.celsius}")150print(f"Fahrenheit: {temp.fahrenheit77.0}")151152temp.celsius = 30153print(f"Updated - Celsius: {temp.celsius}, Fahrenheit: {temp.fahrenheit}")⋯

⋯140@celsius.setter141def celsius(self⟨Temperature F⟩, value30):142    self._celsius→ 30 = value30⋯

⋯152temp.celsius→ 30 = 30153print(f"Updated - Celsius: {temp.celsius30}, Fahrenheit: {temp.fahrenheit86.0}")⋯

⋯136@property137def celsius(self⟨Temperature F⟩):138    return self._celsius30⋯

⋯144@property145def fahrenheit(self⟨Temperature F⟩):146    return self._celsius30 * 9/5 + 32⋯

⋯152temp.celsius = 30153print(f"Updated - Celsius: {temp.celsius30}, Fahrenheit: {temp.fahrenheit86.0}")154155# Weakref support156print("\nWeakref support:")157158import weakref159160# Without __weakref__ in __slots__, weakref fails161class NoWeakref:162    __slots__ = ['value']163    164    def __init__(self, value):165        self.value = value166167obj1 = NoWeakref(42)⋯

⋯164def __init__(self⟨NoWeakref G⟩, value42):165    self.value→ 42 = value42⋯

⋯167obj1→ ⟨NoWeakref G⟩ = NoWeakref(42)⋯

⋯169try:170    ref = weakref<module 'weakref' from '/usr/local/lib/python3.12/weakref.py'>.ref(obj1⟨NoWeakref G⟩)171except TypeError as e:⋯

⋯170    ref = weakref.ref(obj1)171except TypeError as e:172    print(f"Error without __weakref__: {ecannot create weak reference to 'NoWeakref' object}")⋯

⋯175class WithWeakref:176    __slots__ = ['value', '__weakref__']177    178    def __init__(self, value):179        self.value = value180181obj2 = WithWeakref(42)182ref = weakref.ref(obj2)⋯

⋯178def __init__(self⟨WithWeakref H⟩, value42):179    self.value→ 42 = value42⋯

⋯181obj2→ ⟨WithWeakref H⟩ = WithWeakref(42)182ref→ ⟨weakref at ⟨addr I⟩; to 'WithWeakref' H⟩ = weakref<module 'weakref' from '/usr/local/lib/python3.12/weakref.py'>.ref(obj2⟨WithWeakref H⟩)183print(f"Weakref created: {ref()}")184print(f"Weakref value: {ref().value}")185186# Pickle support187print("\nPickle support:")188189import pickle190191class PickleSlots:192    __slots__ = ['name', 'value']193    194    def __init__(self, name, value):195        self.name = name196        self.value = value197198obj = PickleSlots("test", 123)⋯

⋯194def __init__(self⟨PickleSlots J⟩, nametest, value123):195    self.name→ test = nametest196    self.value→ 123 = value123⋯

⋯198obj→ ⟨PickleSlots J⟩ = PickleSlots("test", 123)199200# Pickle and unpickle201pickled→ b'\x80\x04\x95?\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x0bPickleSlots\x94\x93\x94)\x81\x94N}\x94(\x8c\x04name\x94\x8c\x04test\x94\x8c\x05value\x94K{u\x86\x94b.' = pickle<module 'pickle' from '/usr/local/lib/python3.12/pickle.py'>.dumps(obj⟨PickleSlots J⟩)202restored→ ⟨PickleSlots B⟩ = pickle<module 'pickle' from '/usr/local/lib/python3.12/pickle.py'>.loads(pickledb'\x80\x04\x95?\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x0bPickleSlots\x94\x93\x94)\x81\x94N}\x94(\x8c\x04name\x94\x8c\x04test\x94\x8c\x05value\x94K{u\x86\x94b.')203204print(f"Original: {obj.nametest}, {obj.value123}")205print(f"Restored: {restored.nametest}, {restored.value123}")206207# Practical example208print("\nPractical example:")209210class ImmutablePoint:211    __slots__ = ['_x', '_y']212    213    def __init__(self, x, y):214        object.__setattr__(self, '_x', x)215        object.__setattr__(self, '_y', y)216    217    @property218    def x(self):219        return self._x220    221    @property222    def y(self):223        return self._y224    225    def __setattr__(self, name, value):226        raise AttributeError(f"Cannot modify immutable attribute '{name}'")227    228    def __repr__(self):229        return f"ImmutablePoint({self._x}, {self._y})"230231p = ImmutablePoint(10, 20)232print(f"Point: {p}")⋯

⋯213def __init__(self(empty), x10, y20):214    object.__setattr__(self, '_x', x10)215    object.__setattr__(self, '_y', y20)⋯

⋯231p→ ImmutablePoint(10, 20) = ImmutablePoint(10, 20)232print(f"Point: {pImmutablePoint(10, 20)}")233print(f"x={p.x10}, y={p.y20}")⋯

⋯217@property218def x(selfImmutablePoint(10, 20)):219    return self._x10⋯

⋯221@property222def y(selfImmutablePoint(10, 20)):223    return self._y20⋯

⋯232print(f"Point: {p}")233print(f"x={p.x10}, y={p.y20}")⋯

⋯225def __setattr__(selfImmutablePoint(10, 20), namex, value30):226    raise AttributeError(f"Cannot modify immutable attribute '{namex}'")⋯

⋯237    p.x = 30238except AttributeError as e:239    print(f"Error: {eCannot modify immutable attribute 'x'}")⋯

⋯225def __setattr__(selfImmutablePoint(10, 20), namez, value40):226    raise AttributeError(f"Cannot modify immutable attribute '{namez}'")⋯

⋯243    p.z = 40244except AttributeError as e:245    print(f"Error: {eCannot modify immutable attribute 'z'}")⋯

1"""__slots__ with inheritance"""23# Basic inheritance4print("Basic inheritance:")56class Base:7    __slots__ = ['x']8    9    def __init__(self, x):10        self.x = x1112class Derived(Base):13    __slots__ = ['y']  # Only add new slots14    15    def __init__(self, x, y):16        super().__init__(x)17        self.y = y1819obj = Derived(10, 20)20print(f"x={obj.x}, y={obj.y}")⋯

⋯15def __init__(self⟨Derived A⟩, x10, y20):16    super().__init__(x)17    self.y = y⋯

⋯9def __init__(self⟨Derived A⟩, x10):10    self.x→ 10 = x10⋯

⋯16super().__init__(x)17self.y→ 20 = y20⋯

⋯19obj→ ⟨Derived A⟩ = Derived(10, 20)20print(f"x={obj.x10}, y={obj.y20}")21print(f"Base __slots__: {Base.__slots__['x']}")22print(f"Derived __slots__: {Derived.__slots__['y']}")⋯

⋯26    obj.z = 3027except AttributeError as e:28    print(f"Error: {e'Derived' object has no attribute 'z'}")⋯

⋯30# Empty slots in derived31print("\nEmpty slots in derived:")3233class BaseClass:34    __slots__ = ['a', 'b']35    36    def __init__(self, a, b):37        self.a = a38        self.b = b3940class DerivedClass(BaseClass):41    __slots__ = []  # No new slots42    43    def method(self):44        return self.a + self.b4546obj = DerivedClass(5, 10)47print(f"a={obj.a}, b={obj.b}")⋯

⋯36def __init__(self⟨DerivedClass B⟩, a5, b10):37    self.a→ 5 = a538    self.b→ 10 = b10⋯

⋯46obj→ ⟨DerivedClass B⟩ = DerivedClass(5, 10)47print(f"a={obj.a5}, b={obj.b10}")48print(f"method()={obj⟨DerivedClass B⟩.method()}")⋯

⋯43def method(self⟨DerivedClass B⟩):44    return self.a5 + self.b10⋯

⋯47print(f"a={obj.a}, b={obj.b}")48print(f"method()={obj⟨DerivedClass B⟩.method()}")4950# Parent without __slots__51print("\nParent without __slots__:")5253class ParentNoSlots:54    def __init__(self, x):55        self.x = x5657class ChildWithSlots(ParentNoSlots):58    __slots__ = ['y']59    60    def __init__(self, x, y):61        super().__init__(x)62        self.y = y6364obj = ChildWithSlots(10, 20)⋯

⋯60def __init__(self⟨ChildWithSlots C⟩, x10, y20):61    super().__init__(x)62    self.y = y⋯

⋯53class ParentNoSlots:54    def __init__(self⟨ChildWithSlots C⟩, x10):55        self.x→ 10 = x10⋯

⋯61super().__init__(x)62self.y→ 20 = y20⋯

⋯64obj→ ⟨ChildWithSlots C⟩ = ChildWithSlots(10, 20)6566# Parent has __dict__, child has slots67print(f"Has __dict__: {hasattr(obj⟨ChildWithSlots C⟩, '__dict__')}")68print(f"__dict__: {obj.__dict__{'x': 10}}")  # Contains parent attributes6970# Can add attributes to parent's __dict__71obj.z→ 30 = 3072print(f"Added z: {obj.z30}")7374# But child's slotted attributes are separate75print(f"y (slotted): {obj.y20}")7677# Child without __slots__78print("\nChild without __slots__:")7980class ParentWithSlots:81    __slots__ = ['x']82    83    def __init__(self, x):84        self.x = x8586class ChildNoSlots(ParentWithSlots):87    # No __slots__ means __dict__ is created88    def __init__(self, x, y):89        super().__init__(x)90        self.y = y  # Stored in __dict__9192obj = ChildNoSlots(10, 20)93print(f"x (slotted): {obj.x}")⋯

⋯87# No __slots__ means __dict__ is created88def __init__(self⟨ChildNoSlots D⟩, x10, y20):89    super().__init__(x)90    self.y = y  # Stored in __dict__⋯

⋯83def __init__(self⟨ChildNoSlots D⟩, x10):84    self.x→ 10 = x10⋯

⋯89super().__init__(x)90self.y→ 20 = y20  # Stored in __dict__⋯

⋯92obj→ ⟨ChildNoSlots D⟩ = ChildNoSlots(10, 20)93print(f"x (slotted): {obj.x10}")94print(f"y (dict): {obj.y20}")95print(f"Has __dict__: {hasattr(obj⟨ChildNoSlots D⟩, '__dict__')}")9697# Can add dynamic attributes98obj.z→ 30 = 3099print(f"Added z: {obj.z30}")100101# Multiple inheritance102print("\nMultiple inheritance:")103104class A:105    __slots__ = ['a']106107class B(A):108    __slots__ = ['b']109110class C(B):111    __slots__ = ['c']112113    def __init__(self, a, b, c):114        self.a = a115        self.b = b116        self.c = c117118obj = C(1, 2, 3)119print(f"a={obj.a}, b={obj.b}, c={obj.c}")⋯

⋯113def __init__(self⟨C E⟩, a1, b2, c3):114    self.a→ 1 = a1115    self.b→ 2 = b2116    self.c→ 3 = c3⋯

⋯118obj→ ⟨C E⟩ = C(1, 2, 3)119print(f"a={obj.a1}, b={obj.b2}, c={obj.c3}")120121# Diamond inheritance122print("\nDiamond inheritance:")123124class Base2:125    __slots__ = ['value']126127class Left(Base2):128    __slots__ = ['left_value']129130# For diamond to work, only one branch can have non-empty __slots__131class Right(Base2):132    __slots__ = []  # Empty slots - avoids layout conflict133134class Diamond(Left, Right):135    __slots__ = ['diamond_value']136137    def __init__(self, value, left, diamond):138        self.value = value139        self.left_value = left140        self.diamond_value = diamond141142obj = Diamond(1, 2, 3)143print(f"value={obj.value}, left={obj.left_value}, diamond={obj.diamond_value}")⋯

⋯137def __init__(self⟨Diamond F⟩, value1, left2, diamond3):138    self.value→ 1 = value1139    self.left_value→ 2 = left2140    self.diamond_value→ 3 = diamond3⋯

⋯142obj→ ⟨Diamond F⟩ = Diamond(1, 2, 3)143print(f"value={obj.value1}, left={obj.left_value2}, diamond={obj.diamond_value3}")144145# Override with __dict__146print("\nOverride with __dict__:")147148class Parent:149    __slots__ = ['x']150151class Child(Parent):152    __slots__ = ['y', '__dict__']  # Add __dict__ explicitly153    154    def __init__(self, x, y):155        self.x = x156        self.y = y157158obj = Child(10, 20)159print(f"x={obj.x}, y={obj.y}")⋯

⋯154def __init__(self⟨Child G⟩, x10, y20):155    self.x→ 10 = x10156    self.y→ 20 = y20⋯

⋯158obj→ ⟨Child G⟩ = Child(10, 20)159print(f"x={obj.x10}, y={obj.y20}")160161# Can now add dynamic attributes162obj.z→ 30 = 30163print(f"Added z: {obj.z30}")164print(f"__dict__: {obj.__dict__{'z': 30}}")165166# Mixin classes167print("\nMixin classes:")168169class SlottedBase:170    __slots__ = ['id', 'name']171172class Mixin:173    def get_info(self):174        return f"{self.name} (ID: {self.id})"175176class ConcreteClass(SlottedBase, Mixin):177    __slots__ = ['email']178    179    def __init__(self, id, name, email):180        self.id = id181        self.name = name182        self.email = email183184obj = ConcreteClass(1, "Alice", "alice@example.com")185print(f"Info: {obj.get_info()}")⋯

⋯179def __init__(self⟨ConcreteClass H⟩, id1, nameAlice, emailalice@example.com):180    self.id→ 1 = id1181    self.name→ Alice = nameAlice182    self.email→ alice@example.com = emailalice@example.com⋯

⋯184obj→ ⟨ConcreteClass H⟩ = ConcreteClass(1, "Alice", "alice@example.com")185print(f"Info: {obj⟨ConcreteClass H⟩.get_info()}")186print(f"Email: {obj.email}")⋯

⋯172class Mixin:173    def get_info(self⟨ConcreteClass H⟩):174        return f"{self.nameAlice} (ID: {self.id1})"⋯

⋯184obj = ConcreteClass(1, "Alice", "alice@example.com")185print(f"Info: {obj⟨ConcreteClass H⟩.get_info()}")186print(f"Email: {obj.emailalice@example.com}")187188# Practical example189print("\nPractical example:")190191# Shape hierarchy192class Shape:193    __slots__ = ['color']194    195    def __init__(self, color):196        self.color = color197198class Circle(Shape):199    __slots__ = ['radius']200    201    def __init__(self, color, radius):202        super().__init__(color)203        self.radius = radius204    205    def area(self):206        import math207        return math.pi * self.radius ** 2208209class Rectangle(Shape):210    __slots__ = ['width', 'height']211    212    def __init__(self, color, width, height):213        super().__init__(color)214        self.width = width215        self.height = height216    217    def area(self):218        return self.width * self.height219220circle = Circle("red", 5)221rectangle = Rectangle("blue", 10, 20)⋯

⋯201def __init__(self⟨Circle I⟩, colorred, radius5):202    super().__init__(color)203    self.radius = radius⋯

⋯195def __init__(self⟨Circle I⟩, colorred):196    self.color→ red = colorred⋯

⋯202super().__init__(color)203self.radius→ 5 = radius5⋯

⋯220circle→ ⟨Circle I⟩ = Circle("red", 5)221rectangle = Rectangle("blue", 10, 20)⋯

⋯212def __init__(self⟨Rectangle J⟩, colorblue, width10, height20):213    super().__init__(color)214    self.width = width⋯

⋯195def __init__(self⟨Rectangle J⟩, colorblue):196    self.color→ blue = colorblue⋯

⋯213super().__init__(color)214self.width→ 10 = width10215self.height→ 20 = height20⋯

⋯220circle = Circle("red", 5)221rectangle→ ⟨Rectangle J⟩ = Rectangle("blue", 10, 20)222223print(f"Circle: color={circle.colorred}, radius={circle.radius5}, area={circle⟨Circle I⟩.area():.2f}")224print(f"Rectangle: color={rectangle.color}, width={rectangle.width}, height={rectangle.height}, area={rectangle.area()}")⋯

⋯205def area(self⟨Circle I⟩):206    import math207    return math.pi3.141592653589793 * self.radius5 ** 2⋯

⋯223print(f"Circle: color={circle.colorred}, radius={circle.radius5}, area={circle⟨Circle I⟩.area():.2f}")224print(f"Rectangle: color={rectangle.colorblue}, width={rectangle.width10}, height={rectangle.height20}, area={rectangle⟨Rectangle J⟩.area()}")⋯

⋯217def area(self⟨Rectangle J⟩):218    return self.width10 * self.height20⋯

⋯223print(f"Circle: color={circle.color}, radius={circle.radius}, area={circle.area():.2f}")224print(f"Rectangle: color={rectangle.colorblue}, width={rectangle.width10}, height={rectangle.height20}, area={rectangle⟨Rectangle J⟩.area()}")⋯

1"""When to use __slots__"""23# When to use __slots__4print("When to use __slots__:")56# 1. Many instances7class Particle:8    __slots__ = ['x', 'y', 'vx', 'vy']9    10    def __init__(self, x, y, vx, vy):11        self.x = x12        self.y = y13        self.vx = vx14        self.vy = vy1516# Useful when creating thousands/millions17particles = [Particle(i, i*2, i*3, i*4) for i in range(100)]18print(f"✓ Good: Created {len(particles)} particles with __slots__")⋯

⋯10def __init__(self⟨Particle A⟩, x0, y0, vx0, vy0):11    self.x→ 0 = x012    self.y→ 0 = y013    self.vx→ 0 = vx014    self.vy→ 0 = vy0⋯

⋯16# Useful when creating thousands/millions17particles→ [⟨Particle A⟩, ⟨Particle B⟩, ⟨Particle C⟩, ⟨Particle D⟩, ⟨Particle E⟩, ⟨Particle F⟩, ⟨Particle G⟩, ⟨Particle H⟩, ⟨Particle I⟩, ⟨Particle L⟩, ⟨Particle M⟩, ⟨Particle N⟩, ⟨Particle O⟩, ⟨Particle P⟩, ⟨Particle Q⟩, ⟨Particle R⟩, ⟨Particle S⟩, ⟨Particle T⟩, ⟨Particle U⟩, ⟨Particle V⟩, ⟨Particle W⟩, ⟨Particle X⟩, ⟨Particle Y⟩, ⟨Particle Z⟩, ⟨Particle AA⟩, ⟨Particle AB⟩, ⟨Particle AC⟩, ⟨Particle AD⟩, ⟨Particle AE⟩, ⟨Particle AF⟩, ⟨Particle AG⟩, ⟨Particle AH⟩, ⟨Particle AI⟩, ⟨Particle AJ⟩, ⟨Particle AK⟩, ⟨Particle AL⟩, ⟨Particle AM⟩, ⟨Particle AN⟩, ⟨Particle AO⟩, ⟨Particle AP⟩, ⟨Particle AQ⟩, ⟨Particle AR⟩, ⟨Particle AS⟩, ⟨Particle AT⟩, ⟨Particle AU⟩, ⟨Particle AV⟩, ⟨Particle AW⟩, ⟨Particle AX⟩, ⟨Particle AY⟩, ⟨Particle AZ⟩, ⟨Particle BA⟩, ⟨Particle BB⟩, ⟨Particle BC⟩, ⟨Particle BD⟩, ⟨Particle BE⟩, ⟨Particle BF⟩, ⟨Particle BG⟩, ⟨Particle BH⟩, ⟨Particle BI⟩, ⟨Particle BJ⟩, ⟨Particle BK⟩, ⟨Particle BL⟩, ⟨Particle BM⟩, ⟨Particle BN⟩, ⟨Particle BO⟩, ⟨Particle BP⟩, ⟨Particle BQ⟩, ⟨Particle BR⟩, ⟨Particle BS⟩, ⟨Particle BT⟩, ⟨Particle BU⟩, ⟨Particle BV⟩, ⟨Particle BW⟩, ⟨Particle BX⟩, ⟨Particle BY⟩, ⟨Particle BZ⟩, ⟨Particle CA⟩, ⟨Particle CB⟩, ⟨Particle CC⟩, ⟨Particle CD⟩, ⟨Particle CE⟩, ⟨Particle CF⟩, ⟨Particle CG⟩, ⟨Particle CH⟩, ⟨Particle CI⟩, ⟨Particle CJ⟩, ⟨Particle CK⟩, ⟨Particle CL⟩, ⟨Particle CM⟩, ⟨Particle CN⟩, ⟨Particle CO⟩, ⟨Particle CP⟩, ⟨Particle CQ⟩, ⟨Particle CR⟩, ⟨Particle CS⟩, ⟨Particle CT⟩, ⟨Particle CU⟩, ⟨Particle CV⟩, ⟨Particle J⟩, ⟨Particle K⟩] = [Particle(i, i*2, i*3, i*4) for i in range(100)]18print(f"✓ Good: Created {len(particles[⟨Particle A⟩, ⟨Particle B⟩, ⟨Particle C⟩, ⟨Particle D⟩, ⟨Particle E⟩, ⟨Particle F⟩, ⟨Particle G⟩, ⟨Particle H⟩, ⟨Particle I⟩, ⟨Particle L⟩, ⟨Particle M⟩, ⟨Particle N⟩, ⟨Particle O⟩, ⟨Particle P⟩, ⟨Particle Q⟩, ⟨Particle R⟩, ⟨Particle S⟩, ⟨Particle T⟩, ⟨Particle U⟩, ⟨Particle V⟩, ⟨Particle W⟩, ⟨Particle X⟩, ⟨Particle Y⟩, ⟨Particle Z⟩, ⟨Particle AA⟩, ⟨Particle AB⟩, ⟨Particle AC⟩, ⟨Particle AD⟩, ⟨Particle AE⟩, ⟨Particle AF⟩, ⟨Particle AG⟩, ⟨Particle AH⟩, ⟨Particle AI⟩, ⟨Particle AJ⟩, ⟨Particle AK⟩, ⟨Particle AL⟩, ⟨Particle AM⟩, ⟨Particle AN⟩, ⟨Particle AO⟩, ⟨Particle AP⟩, ⟨Particle AQ⟩, ⟨Particle AR⟩, ⟨Particle AS⟩, ⟨Particle AT⟩, ⟨Particle AU⟩, ⟨Particle AV⟩, ⟨Particle AW⟩, ⟨Particle AX⟩, ⟨Particle AY⟩, ⟨Particle AZ⟩, ⟨Particle BA⟩, ⟨Particle BB⟩, ⟨Particle BC⟩, ⟨Particle BD⟩, ⟨Particle BE⟩, ⟨Particle BF⟩, ⟨Particle BG⟩, ⟨Particle BH⟩, ⟨Particle BI⟩, ⟨Particle BJ⟩, ⟨Particle BK⟩, ⟨Particle BL⟩, ⟨Particle BM⟩, ⟨Particle BN⟩, ⟨Particle BO⟩, ⟨Particle BP⟩, ⟨Particle BQ⟩, ⟨Particle BR⟩, ⟨Particle BS⟩, ⟨Particle BT⟩, ⟨Particle BU⟩, ⟨Particle BV⟩, ⟨Particle BW⟩, ⟨Particle BX⟩, ⟨Particle BY⟩, ⟨Particle BZ⟩, ⟨Particle CA⟩, ⟨Particle CB⟩, ⟨Particle CC⟩, ⟨Particle CD⟩, ⟨Particle CE⟩, ⟨Particle CF⟩, ⟨Particle CG⟩, ⟨Particle CH⟩, ⟨Particle CI⟩, ⟨Particle CJ⟩, ⟨Particle CK⟩, ⟨Particle CL⟩, ⟨Particle CM⟩, ⟨Particle CN⟩, ⟨Particle CO⟩, ⟨Particle CP⟩, ⟨Particle CQ⟩, ⟨Particle CR⟩, ⟨Particle CS⟩, ⟨Particle CT⟩, ⟨Particle CU⟩, ⟨Particle CV⟩, ⟨Particle J⟩, ⟨Particle K⟩])} particles with __slots__")1920# Fixed attributes21print("\nFixed attributes:")2223class DatabaseRecord:24    __slots__ = ['id', 'timestamp', 'user_id', 'action', 'data']⋯

⋯26def __init__(self⟨DatabaseRecord CW⟩, id1, timestamp1234567890, user_id42, actionlogin, data{'ip': '127.0.0.1'}):27    self.id→ 1 = id128    self.timestamp→ 1234567890 = timestamp123456789029    self.user_id→ 42 = user_id4230    self.action→ login = actionlogin31    self.data→ {'ip': '127.0.0.1'} = data{'ip': '127.0.0.1'}⋯

⋯33record = DatabaseRecord(1, 1234567890, 42, "login", {"ip": "127.0.0.1"})34print(f"✓ Good: Fixed schema prevents typos")3536# Data classes37print("\nData classes:")3839class Point3D:40    __slots__ = ['x', 'y', 'z']41    42    def __init__(self, x, y, z):43        self.x = x44        self.y = y45        self.z = z46    47    def __repr__(self):48        return f"Point3D({self.x}, {self.y}, {self.z})"49    50    def distance_from_origin(self):51        return (self.x**2 + self.y**2 + self.z**2) ** 0.55253p = Point3D(3, 4, 5)54print(f"✓ Good: Simple data container")⋯

⋯42def __init__(self(empty), x3, y4, z5):43    self.x→ 3 = x344    self.y→ 4 = y445    self.z→ 5 = z5⋯

⋯53p→ Point3D(3, 4, 5) = Point3D(3, 4, 5)54print(f"✓ Good: Simple data container")55print(f"  Point: {pPoint3D(3, 4, 5)}, distance: {p.distance_from_origin():.2f}")⋯

⋯50def distance_from_origin(selfPoint3D(3, 4, 5)):51    return (self.x3**2 + self.y4**2 + self.z5**2) ** 0.5⋯

⋯54print(f"✓ Good: Simple data container")55print(f"  Point: {pPoint3D(3, 4, 5)}, distance: {p.distance_from_origin():.2f}")5657# When NOT to use __slots__58print("\nWhen NOT to use __slots__:")5960# 1. Dynamic attributes needed61class FlexibleConfig:62    # Don't use __slots__ here63    def __init__(self):64        self.settings = {}65    66    def set(self, key, value):67        self.settings[key] = value6869config = FlexibleConfig()70config.debug = True  # Need this flexibility⋯

⋯62# Don't use __slots__ here63def __init__(self⟨FlexibleConfig CX⟩):64    self.settings→ {} = {}⋯

⋯69config→ ⟨FlexibleConfig CX⟩ = FlexibleConfig()70config.debug→ True = True  # Need this flexibility71config.timeout→ 30 = 3072print(f"✗ Bad for __slots__: Dynamic attributes needed")7374# Few instances75print("\nFew instances:")7677# Don't use __slots__ for singletons or few instances78class AppConfig:79    # No need for __slots__ - only one instance80    def __init__(self):81        self.host = "localhost"82        self.port = 808083        self.debug = False8485config = AppConfig()86print(f"✗ Bad for __slots__: Only a few instances")⋯

⋯79# No need for __slots__ - only one instance80def __init__(self⟨AppConfig CY⟩):81    self.host→ localhost = "localhost"82    self.port→ 8080 = 808083    self.debug→ False = False⋯

⋯85config→ ⟨AppConfig CY⟩ = AppConfig()86print(f"✗ Bad for __slots__: Only a few instances")8788# Complex inheritance89print("\nComplex inheritance:")9091# Avoid __slots__ with complex inheritance hierarchies92class Base:93    def __init__(self):94        self.base_attr = "base"9596class Mixin1:97    def method1(self):98        return "mixin1"99100class Mixin2:101    def method2(self):102        return "mixin2"103104class ComplexClass(Base, Mixin1, Mixin2):105    # Don't add __slots__ here - too complex106    def __init__(self):107        super().__init__()108        self.extra = "extra"109110obj = ComplexClass()111print(f"✗ Bad for __slots__: Complex inheritance")⋯

⋯105# Don't add __slots__ here - too complex106def __init__(self⟨ComplexClass CZ⟩):107    super().__init__()108    self.extra = "extra"⋯

⋯92class Base:93    def __init__(self⟨ComplexClass CZ⟩):94        self.base_attr→ base = "base"⋯

⋯107super().__init__()108self.extra→ extra = "extra"⋯

⋯110obj→ ⟨ComplexClass CZ⟩ = ComplexClass()111print(f"✗ Bad for __slots__: Complex inheritance")112113# Performance-critical code114print("\nPerformance-critical code:")115116class Vector:117    __slots__ = ['x', 'y']118    119    def __init__(self, x, y):120        self.x = x121        self.y = y122    123    def __add__(self, other):124        return Vector(self.x + other.x, self.y + other.y)125    126    def dot(self, other):127        return self.x * other.x + self.y * other.y128129# Good for tight loops130v1 = Vector(1, 2)131v2 = Vector(3, 4)⋯