Python-Advanced-Python-Data-Structures on Janusworx

A Hundred Days of Code, Day 013, Day 14 - Python, Advanced Data Structures, Done!

feedback@janusworx.com (Mario Jason Braganza) — Wed, 22 Jul 2020 17:48:09 +0530

Notes and experiences for yesterday and today.
I ‘wasted’ a lot of time, again, struggling with exercises yesterday and ended up being too zombied to even write the summary post.
Have been much smarter about it today.
Stopped after about 30 mins and copied and tried to understand the solution.

Notes
#

List of Dictionaries

Just more convenient than a list of lists, not particularly faster
Make it more flexible.

Dictionary of dictionaries

Think beforehand of what your keys are going to be.
Looking in them, faster than lists
The tradeoff is more memory usage

Dictionary of Lists

Works when you need disparate elements to work with later. Those can be stored as dictionary values, in a list form.

Part 3

Decimals

To have something sane between integers and crazy floats.
I import the Decimal class and then create objects, like so

from decimal import Decimal
a = Decimal('0.1')
b = Decimal('0.2')

I create them from strings not floats, just like I would int strings.
It has various methods I can call on the Decimal object.
- Stuff like getcontext with has a method to set the precision of units after the decimal point.
Helpful if you need precision at a certain level.

Named Tuples

A very handy way of calling values in a tuple by sensible names, just like dictionaries
Very handy instead of heavyweight dictionaries.
Create them like so

from collections import namedtuple 
Person = namedtuple('Person', ['first', 'last', 'age']) 
me = Person('Jason', 'Braganza', 42) 

Doing a me.first will get me Jason, just like a dictionary.
I can still refer to the tuples with the numeric indices.
I can do a ._replace to replace values, if I want to. me._replace(first ='Mario'). It just returns a new object with the same name, which I can choose to catch in a new variable.
Better for readability.
Basic uses. The moment I want to twiddle with it too much, I know I should just make my own classes

defaultdict

A variation/improvement on the normal dictionary.
We want a dictionary, with default values.
When I check for the presence of a key, if it does not exist it’ll get created with a default value.
We give it a function or a class, that will run, be called everytime a key does not exist.
So I could pass it basic primitives, like a list with no entries and it will return an empty list for a value everytime, there is not one. Or saying int, in which case it will create a key with 0 for a value
Create them like so

from collections import defaultdict 
d = defaultdict(int) 

So now when I do d['a'], it well check for key a. If it does not exist, it will create it, and give it a value of 0 by running the int function with no arguments.
I can use any function or callable, as long as it has no arguments.

OrderedDict

No need to use it anymore
But handy in case I am looking at old code.
Regular dictionaries order stuff chronolgically as of Python 3.7.
Which is what ordered dictionaries used to do.

Counter

from collections import Counter
if I pass an Counter dictionary an iterable, it will create a dictionary with the occurrence of each element.
if I go c = Counter[10, 10, 20, 50, 60, 60, 80, 80, 80, 90'], then I get a dictionary like Counter({10: 2, 20: 1, 50: 1, 60: 2, 80: 3, 90: 1})
I can also do a most common method to get the most frequently used elements. c.most_common()

Enums

from enum import Enum
Create ’em like

class ColorEnum(Enum)
Red = 1
Blue = 2
Green = 3

Matches symbolic labels / names to numeric values.
If a = ColorEnum.Red and b=ColorEnum.Red then they would both be equal.

Learning / Feedback/ Experiences from doing exercises
#

Reuven keeps harping on the fact, that I need to think things through.
- Is this how you want to build things?
- What are the ramifications?
- What if you want to change up things or if things are expected to grow exponentially in the future?
- Think! Be itentional. Design accordingly.
Caught myself frequently initalising a total in a loop and then wondering why I would not get the actual total :)
Now my approach, kinda matches what Reuven does. Which means, I am beginning to write some sane code :)
Finished with this course. And on to the next one. Planning, building in margin and working at it a little bit everyday helping a lot!

Read all about my Python advanced data structures journey here.

A Hundred Days of Code, Day 012 - Python, Advanced Data Structures continued

feedback@janusworx.com (Mario Jason Braganza) — Mon, 20 Jul 2020 16:21:04 +0530

Ok! Had a nice refreshing break, yesterday being Sunday.
Back to work today!
If today’s notes, feel a little light, that’s because I was struggling with exercises.

Notes
#

Part 2

A lightweight solution to classes, if I am just combining all sorts of data structures is the built-in collections. Some of them could be
- List of Lists
- List of Tuples
- List of Dictionaries
- Dictionary of Dictionaries
- Dictionary of Lists
Mostly use them to solve tricky issues. If I find myself using lots of functions, just to deal with these structures, I am better off using classes.
- These structures also lend themselves to being converted into classes.
- Sometimes it’s just a matter of adding a few methods, et voilà, I have a class!

Lists of lists

As simple to create as l = [[1,3,2],[4,5,6],[7,8,9]]
- If I do a l[0], I’ll get the first element, the list [1,3,2
- To get at the elements inside that list, I can go l[0][2] which will give me the number, 3.
- Behind the scenes, l.__getitem__(0).__getitem__(2)
We can either work with them with indices like up above, or iterate over them, with for loops or comprehensions
Better to use lists of tuples, if I am dealing with mixed types, specially those that are not apt to change, like records of some sort. Something like a list of details about movies.

Learning / Feedback/ Experiences from doing exercises
#

Learning to think atomically. Learning to break down each exercise into pieces and then learning to organise them in a manner, that I can solve it, step by step.
- What hints do Reuven’s results show?
- What should I compare first? What will be the aftermath? and so on.
Gave up an exercise after two hours of trying.
- After peeking at the solution I realised that it was not because of something I forgot or did not practice, but once again, because of something I did not know.
- in this case that there are set operators to use between two iterator objects.instead of crazily stepping through everything like I did below, I could’ve just created a union list run through them.
Just goes to show, there is lots for me to learn. And that there is a lot of tacit knowledge out there. And this I will only be able to figure out by writing lots of code!
Also (note to self), time your self and be ok with giving up and looking at the solution. I seem to keep thinking that I am wrong or am missing something. Never the fact, that it might be something that I do not know.
- I am now strictly going to give myself 30 minutes per exercise and then move on.
Lots of mistakes as usual.
- Wrong indentation, giving weird results.

Read all about my Python advanced data structures journey here

A Hundred Days of Code, Day 011 - Python, Advanced Data Structures

feedback@janusworx.com (Mario Jason Braganza) — Sat, 18 Jul 2020 19:14:17 +0530

Started with a new Reuven Lerner Course, on Advanced Data Structures..
Aiming to comfortably finish this in a week.
Notes and experiences, follow.
The course is three parts.

Part 1 - Deep dive into the common data structures
Part 2 - Combining Data Structures. Lists of lists, Dicts of lists, Tuples of Lists and so forth. How far can I go without classes? Or how can I enhance my classes with this approach?
Part 3 - Complex data structures, that come with the Python Standard Library. The Collections module, Weak references etc.

Notes
#

Part 1

The id of a variable shows me where the object in refers to, is located in memory.
If x=5 then the id(x) will point to where it’s object, here the number 5, is located in memory.
When I assign a variable to another, what I actually do is assign the new variable to the same objects address. That is all. When I do x = y, then y will point to 5 too, independent of x. If I set x to something else later, y is not going to follow x. Instead it steadfastly points to 5.
A simple way to say this is x is y, where I am not checking for equality, but rather testing the fact, that both of them point to the same location in memory, or not.
I can use sys.getsizeof() to find the size of an object in memory. (how much memory it uses), but it’s a tricky beast. For e.g. when it shows me the size of a list, it shows me the size of the list object. Not the size of the elements it contains. To get that, I need to go check the size of its elements one by one.
A singleton object (not many in Python) is an object that every time you create a new instance of, from the parent class, it always points back to the same instance. None is an example in Python.
Better to create a list using square brackets, rather than assigning them via a string. x = ['a','b','c','d'] works better than going x = list('abcd'). This obviously matters upon what you are doing and if that is possible to do or not.
I can tuple-unpack-split a string in various ways. If I go, a, b, *c = s.split[] it will get the first split item in a, the next one in b, and the rest will be a list in c. But if I want the first and last elements for example and don’t care about the stuff in the middle, I can also go, a, *b, c = s.split(). I need to play with this. Just realised I could’ve solved a lot of exercises I did in the past, more elegantly if I knew this then.
If I access an element in a sequence via its index, I will get the element back along with the elements type, but if I slice a sequence to get just one element back, I get a single element of the sequence’s type. Very nifty!
- For example if I access s[0] in the list ['jason', 'braganza'], then I will get a string jason back.
- But if I slice and get just the first element with a s[:1] (get upto, but not including 1), I get a single element list, ['jason'] back.
If I look up a key z in a dictionary d with a d[z] and it does not exist, then I get a KeyError. If I want to check keys without noise, I use the get method on a dictionary. If the key exists, the value is returned. If not None comes back.
- I can set keys similarly with the setdefault key if I want to set keys safely. If I just do d[z] = 100 and z already existed, its value would have gotten trampled and set to 1000. But if I do the samething with a d.setdefault(z, 100) then it sets it to 100 only if the key does not exist. If it does, it just returns the old existing value. No harm, no foul.
If I have two dictionaries and I want the contents of one in the other, then I use the update method. For e.g., I have dictionary a and dictionary b, so I do a.update(b) and everything from b flows into a.
- If there is overlap in the keys, then the values get trampled and overwritten.
I normally cannot add dictionaries, lists, or other sets to my sets (no unhashable types allowed), I can freeze a set with frozenset, which makes it hashable and then add it to my set.

Learning / Feedback/ Experiences from doing exercises
#

Reuven makes Python sound like a cute animated bear. ‘Python notices and says “Oh, you’re using 256. I’ve aleady got that. Don’t create a new object for that!”’ I wish my interpreter was as helpful 😂
This course is a lot less structured than the basic courses. It approaches you from the point of view, that you know stuff, you can read and write Python, you have a modicum of intelligence, so here’s a really juicy grab bag of interesting stuff about all the basics you learnt earlier.
- It’s best to always use f-strings, but if you need to eke performance, can you figure out, what kind of strings are the best? (spoiler, benchmark it)
- While Python lists are expandable, the C structures underyling it are fixed. How does Python let you have flexible, expandable lists then?
And so on and so forth. So far, this has been fascinating.

Read all about my Python advanced data structures journey here

Python-Advanced-Python-Data-Structures on Janusworx

A Hundred Days of Code, Day 013, Day 14 - Python, Advanced Data Structures, Done!

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 012 - Python, Advanced Data Structures continued

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 011 - Python, Advanced Data Structures

Notes #

Learning / Feedback/ Experiences from doing exercises #

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#