def test_globals(self): '''Test globals examples''' self._printf('%sasizeof(%s, limit=%s, code=%s) ... %s', os.linesep, 'globals()', 'MAX', False, '-glob[als]') asizeof.asizeof(globals(), limit=self.MAX, code=False, stats=1) self._print_functions(globals(), 'globals()', opt='-glob[als]') self._printf('%sasizesof(%s, limit=%s, code=%s) ... %s', os.linesep, 'globals(), locals()', 'MAX', False, '-glob[als]') asizeof.asizesof(globals(), locals(), limit=self.MAX, code=False, stats=1) asizeof.asized(globals(), align=0, detail=self.MAX, limit=self.MAX, code=False, stats=1)
def test_iterator(self): '''Test iterator examples''' self._printf('%sasizeof(%s, code=%s) ... %s', os.linesep, '<iterator>', False, '-iter[ator]') o = iter('0123456789') e = iter('') d = iter({}) i = iter(asizeof._items({1:1})) k = iter(asizeof._keys({2:2, 3:3})) v = iter(asizeof._values({4:4, 5:5, 6:6})) l = iter([]) t = iter(()) asizeof.asizesof(o, e, d, i, k, v, l, t, limit=0, code=False, stats=1) asizeof.asizesof(o, e, d, i, k, v, l, t, limit=9, code=False, stats=1)
def test_slots(self): '''Test slots examples''' self._printf('%sasizeof(%s, code=%s) ... %s', os.linesep, '<__slots__>', False, '-slots') class Old: pass # m = None class New(object): __slots__ = ('n',) class Sub(New): __slots__ = {'s': ''} # duplicate! def __init__(self): New.__init__(self) # basic instance sizes o, n, s = Old(), New(), Sub() asizeof.asizesof(o, n, s, limit=self.MAX, code=False, stats=1) # with unique min attr size o.o = 'o' n.n = 'n' s.n = 'S' s.s = 's' asizeof.asizesof(o, n, s, limit=self.MAX, code=False, stats=1) # with duplicate, intern'ed, 1-char string attrs o.o = 'x' n.n = 'x' s.n = 'x' s.s = 'x' asizeof.asizesof(o, n, s, 'x', limit=self.MAX, code=False, stats=1) # with larger attr size o.o = 'o'*1000 n.n = 'n'*1000 s.n = 'n'*1000 s.s = 's'*1000 asizeof.asizesof(o, n, s, 'x'*1000, limit=self.MAX, code=False, stats=1)
def test_asizesof(self): '''Test asizeof.asizesof() ''' self.assertEqual(list(asizeof.asizesof()), []) self.assertRaises(KeyError, asizeof.asizesof, **{'all': True}) objs = [Foo(42), ThinFoo("spam"), OldFoo(67)] sizes = list(asizeof.asizesof(*objs)) objs.reverse() rsizes = list(asizeof.asizesof(*objs)) self.assertEqual(len(sizes), 3) rsizes.reverse() self.assertEqual(sizes, rsizes, (sizes, rsizes)) objs.reverse() isizes = [asizeof.asizeof(obj) for obj in objs] self.assertEqual(sizes, isizes, (sizes, isizes))
def test_asizeof(self): '''Test asizeof.asizeof() ''' self.assertEqual(asizeof.asizeof(), 0) objs = [Foo(42), ThinFoo("spam"), OldFoo(67)] total = asizeof.asizeof(*objs) sizes = list(asizeof.asizesof(*objs)) sum = 0 for sz in sizes: sum += sz self.assertEqual(total, sum, (total, sum))
def test_asizesof(self): '''Test asizeof.asizesof() ''' self.assertEqual(list(asizeof.asizesof()), []) self.assertRaises(KeyError, asizeof.asizesof, **{'all': True}) objs = [Foo(42), ThinFoo("spam"), OldFoo(67)] sizes = list(asizeof.asizesof(*objs)) objs.reverse() rsizes = list(asizeof.asizesof(*objs)) self.assertEqual(len(sizes), 3) rsizes.reverse() self.assertEqual(sizes, rsizes, (sizes, rsizes)) objs.reverse() isizes = [asizeof.asizeof(obj) for obj in objs] self.assertEqual(sizes, isizes) sizer = asizeof.Asizer() asizer_sizes = sizer.asizesof(*objs) self.assertEqual(list(asizer_sizes), sizes) code_sizes = sizer.asizesof(*objs, **dict(code=True)) self.failIfEqual(list(code_sizes), sizes)
def slots_memory(num=0): attrs = list(ascii_letters[:num]) class Unslotted(object): pass class Slotted(object): __slots__ = attrs unslotted = Unslotted() slotted = Slotted() for attr in attrs: unslotted.__dict__[attr] = 0 exec('slotted.%s = 0' % attr, globals(), locals()) memory_use = asizesof(slotted, unslotted, unslotted.__dict__) return memory_use
def test_slots(self): '''Test slots examples''' self._printf('%sasizeof(%s, code=%s) ... %s', os.linesep, '<__slots__>', False, '-slots') class Old: pass # m = None class New(object): __slots__ = ('n', ) class Sub(New): __slots__ = {'s': ''} # duplicate! def __init__(self): New.__init__(self) # basic instance sizes o, n, s = Old(), New(), Sub() asizeof.asizesof(o, n, s, limit=self.MAX, code=False, stats=1) # with unique min attr size o.o = 'o' n.n = 'n' s.n = 'S' s.s = 's' asizeof.asizesof(o, n, s, limit=self.MAX, code=False, stats=1) # with duplicate, intern'ed, 1-char string attrs o.o = 'x' n.n = 'x' s.n = 'x' s.s = 'x' asizeof.asizesof(o, n, s, 'x', limit=self.MAX, code=False, stats=1) # with larger attr size o.o = 'o' * 1000 n.n = 'n' * 1000 s.n = 'n' * 1000 s.s = 's' * 1000 asizeof.asizesof(o, n, s, 'x' * 1000, limit=self.MAX, code=False, stats=1)
recipient="recipient.example.com", body="Hello, World!", ) if sys.version_info.minor >= 7: simple = DataClassMessage( sender="*****@*****.**", recipient="recipient.example.com", body="Hello, World!", ) slotted = SlotMessage( sender="*****@*****.**", recipient="recipient.example.com", body="Hello, World!", ) print("Dataclass %d, Slotted dataclass %d" % asizeof.asizesof(simple, slotted)) attrs = AttrsMessage( sender="*****@*****.**", recipient="recipient.example.com", body="Hello, World!", ) print("NamedTuple %d, Attrs %d" % asizeof.asizesof(pos, attrs)) print( timeit( """m = Message(sender="*****@*****.**", recipient="recipient.example.com",body="Hello, World!",) """, globals=globals(), )) if sys.version_info.minor >= 7:
def to_db(self, server = 'beavis.ph.utexas.edu'): print 'in to_db' sim_blob = {'author': 'Dmitry', 'tags': ['fusion', 'in', '50 years'], 'date': datetime.utcnow()} for key, value in self.__dict__.iteritems(): try: print key, value.__class__, sys.getsizeof(value), asizeof(value) except: print key if type(value) not in ban_types: sim_blob[key] = value elif type(value) == type(np.array([12])): print key, value.nbytes if value.ndim == 1: sim_blob[key] = value.tolist() elif value.size == 1: sim_blob[key] = value else: print 'adding to the db obj', key, type(value), value.shape, value.size if value.size< 1600000: sim_blob[key] = value else: print 'nevermind, ', key, ' is too big' print 'before: ', asizeof(sim_blob), ' ', sys.getsizeof(sim_blob), ' ', flatsize(sim_blob) cutlist = ['pos_i','kx','ky','pdf_x','df_x','v'] #cutlist = ['pos_i','kx','ky','pdf_x','df_x','v'] #cutlist = ['t_stop','dx'] keep_list = ['nz','nx','alpha_c'] for k in cutlist: try: print 'k: ',(sim_blob[k]) sim_blob.pop(k, None) except: print 'not found' #new_blob = {} # for k in keep_list: # new_blob.pop(k, None) # print 'look for bugs' # for k in sim_blob: # print 'trying: ',k#,sim_blob[k] # new_blob[k] = sim_blob[k] # ser_dict = self.serialize(new_blob) # #print sys.getsizeof(new_dict), asizeof(ser_dict), ' ', asizesof(sim_blob) # print BSON.encode(ser_dict).__sizeof__() # exit() #sim_blob = new_blob print 'after: ', asizeof(sim_blob), ' ', sys.getsizeof(sim_blob), ' ', flatsize(sim_blob) print 'coarse_x' in sim_blob print 'df_x' in sim_blob #print type(sim_blob['coarse_x']), sim_blob['coarse_x'][0].__class__ #exit() ser_dict = self.serialize(sim_blob) # for elem in ser_dict: # print elem,': ',type(ser_dict[elem])m #print ser_dict print sys.getsizeof(ser_dict), asizeof(ser_dict), ' ', asizesof(sim_blob) print BSON.encode(ser_dict).__sizeof__() #exit() c = MongoClient(host=server) db = c.new_database print 'db info' print db.command('collstats', 'alpha_runs') alpha_runs = db.alpha_runs alpha_runs.ensure_index('md5', unique=True, dropDups=True) #db.things.ensureIndex({'source_references.key' : 1}, {unique : true, dropDups : true}) try: #print ser_dict.keys() alpha_runs.insert(ser_dict, db) except mongoErr.DuplicateKeyError: alpha_runs.remove({'path': ser_dict['path']}) alpha_runs.remove({'md5': ser_dict['md5']}) #alpha_runs.remove({ "$and" :[{'path': ser_dict['path']},{'md5': ser_dict['md5']}]}) alpha_runs.insert(ser_dict, db) print 'Duplicate run not adding to db, but updating'
lat: float @dataclass class SlotPosition: __slots__ = ['name', 'lon', 'lat'] name: str lon: float lat: float #%% from pympler import asizeof simple = SimplePosition('London', -0.1, 51.5) slot = SlotPosition('Madrid', -3.7, 40.4) asizeof.asizesof(simple, slot) #%% from timeit import timeit timeit('slot.name', setup="slot=SlotPosition('Oslo', 10.8, 59.9)", globals=globals()) # 0.13451020000502467 timeit('simple.name', setup="simple=SimplePosition('Oslo', 10.8, 59.9)", globals=globals()) # 0.13348109999787994 # no difference... #%%
Essentially, slots are defined using .__slots__ to list the variables on a class Variables or attributes not present in .__slots__ may not be defined Furthermore, a slots class may not have default values The benefit of adding such restrictions is that certain optimizations may be done For instance, slots classes take up less memory, as can be measured using Pympler: """ simple = SimplePosition('London', -0.1, 51.5) slot = SlotPosition('Madrid', -3.7, 40.4) print(asizeof.asizesof(simple, slot)) """ Similarly, slots classes are typically faster to work with. The following example measures the speed of attribute access on a slots data class and a regular data class using timeit from the standard library. """ print( timeit('slot.name', setup="slot=SlotPosition('Oslo', 10.8, 59.9)", globals=globals())) print( timeit('simple.name',
def play(self, fun = 4): print("Yaaaaa!") self.boredom -= fun if self.boredom < 0: self.boredom = 0 self.__pass_time() b = Critter2("Anthon") b.talk() b.eat() b.play() b.talk() print() print(b.__slots__) print() print(asizeof.asizesof(a)) print(asizeof.asizesof(b)) #Вывод: при использовании слотов, класс занимает в 2.5 раза меньше памяти(в данном случае) #______________________________________________________________________ def main(): crit_name = input("Critter name: ") crit = Critter(crit_name) choice = None while choice != "0": print(""" 0 - Go out 1 - Health 2 - Feed
def main(): # A named tuple is the previous to the data class NamedTupleCard = namedtuple('NameTupleCard', ['rank','suit']) # Set the NamedTupleCard queen_of_hearts = NamedTupleCard('Q','Hearts') print(queen_of_hearts.rank) # Initialize a data class @dataclass class Position: name: str lon: float lat: float pos = Position('Oslo',10.8, 59.9) print(f'{pos.name} is at {pos.lat} N, {pos.lon} E') '''What's the benefit of a data class? A data class is a regular Python class except for the fact that a class has model methods like .__init__(), .__repr__(), .__eq__() whereas a data class does not require these mandatory methods.''' class PositionSetStandardValues: def __init__(self, name, lon, lat): self.name = name self.lon = lon self.lat = lat @dataclass class PositionSetStandardValues: name: str lon: float = 0.0 lat: float = 0.0 @dataclass class PlayingCard: rank: str suit: str @dataclass class Deck: cards: List[PlayingCard] RANKS = '2 3 4 5 6 7 8 9 10 J Q K A'.split() SUITS = '\u2660 \u2663 \u2665 \u2666'.split() #UTF-8 icons def make_french_deck(): return [PlayingCard(r, s) for s in SUITS for r in RANKS] #print(Deck()) @dataclass class Deck: cards: List[PlayingCard] = field(default_factory=make_french_deck) def __repr__(self): cards = ', '.join(f'{c!s}' for c in self.cards) return f'{self.__class__.__name__}({cards})' print(Deck()) # The field specifier is used to customize each data class individually, # that is, we can have multiple decks of different symbols. # Inheritance with data classes @dataclass class Capital(Position): country: str Capital('Oslo', 10.8, 59.9, 'Norway') # Re-ordering inheritance with data classes @dataclass class Position: name: str lon: float = 0.0 lat: float = 0.0 @dataclass class Capital(Position): country: str = 'Unknown' lat : float = 40.0 # the data class looks for name, lon, lat and country # and Berlin is contained in name Capital('Berlin', country='Germany') # Optimizing data classes # you can use slots for classes to make them faster and use less memory @dataclass class SlotPosition: __slot__ = ['name', 'lon', 'lat'] name: str lon: float lat: float @dataclass class SimplePosition: name: str lon: float lat: float simple = SimplePosition('London', -0.1, 51.5) slot = SlotPosition('Madrid', -3.7, 40.4) print(asizeof.asizesof(simple, slot))