Simple answer: You use lists when you have an ordered collection of things that you'll want to update. You use tuples when you want a list you can't change. You use Dictionaries when you have a collection of label, value pairs. You use sets when you have an unordered collection of unique things. Special considerations on sets: Sets are faster to look up values in than lists and you can use boolean set algebra to fiddle with them, so if you have a collection of unique things where order doesn't matter and you want to do stuff with you probably want a set. More on reddit.com

Choosing the right data structure is crucial for writing efficient and readable code. Python provides several built-in data structures, each with its unique features and use cases. Here, we'll discuss when to use a dictionary, list, or set in Python. More on designgurus.io

IMO: and this is controversial but will greatly help you organize your data, don't lump tuples in with lists, dictionaries, and sets. A tuple isn't a collection, it's a type. That is, use a tuple when your single object has multiple properties. Like a name or a coordinate. A first and last name together form a name, they don't have much value separately, and the constitute the entirely of the object. In this sense, a tuple of first_name, last_name is a single object, not a collection of separate strings. For example, a CSV file is "best" represented as a list of tuples. Each line is a single thing, but with multiple properties all of which are related. Column 1 and column 2 of a row aren't really a sequence or or collection, but rather feathers on the same chicken (tuple). However, Row 1 and row 2 are related only in that they are the same kind of thing stored together (list). We put the tuples in the list because the parts of the row are more related than the rows of the document. Think about type-hinting a tuple vs a list: a list hint takes exactly one type, and the expectation is that there will be several objects of that type. Conversely, a tuple hint easily accepts multiple types, but needs to know the exact number and position of each type. It's not so much that a tuple is an immutable container, but that a tuple stores an immutable thing. List: Use it when you need to store a lot of the same thing. It's ordered, but it doesn't need to be limited to ordered sequences. That is, a list is generally okay as long as the items don't need to be unordered. A list is good at iterating, but bad at selection, so use it when you will be looping over the items, but not selecting at random. Tuple: A tuple is one thing. You generally don't use it for storage, but for structure. When you have a thing with multiple parts, that's a tuple. When you have multiple things, that's a list. Unlike a list, a tuple is very likely to contain different types, while a list is (should) contain elements of a single type. Again, a tuple is good at iteration and bad at selection. A dictionary and set are really close to the same thing--they are hashes. Hashes are bad at iteration, but good at selection, so they are best when you need to select items from the container at random--not in order. They are semi-ordered, meaning you can now expect the order to remain, but if you need items to be in order it's probably not the right type. If you need a key->value relationship, then you want a dict, otherwise, you want a set. Use lists when order matters and you need to modify elements. Order doesn't need to matter, it just needs to be inconsequential. Also, avoid the "modify" criteria as almost all "real" collections are modifiable. Lists end up being sort of a "default", so without a reason to choose something else, or a reason to avoid a list, most of the time a list is fine. Use tuples when you need an immutable sequence (e.g., function return values). Again, look at this as a single object. Use tuples when you are returning a complex single object, not a sequence. You can return a list from a function just as easily as a tuple, so I don't consider return values a good selection criteria. However, your function should be returning "one thing", so in that sense a tuple makes sense, but from the other direction. Use sets when you need fast lookups and uniqueness. Use dictionaries when mapping keys to values efficiently. again, I would avoid thinking about sets and dictionaries as a top-level division. Instead, think "do I need a hash", and then "do I need key->value pairs" to choose between them. Is this not actually a collection of separate, but similar, objects? Then you want a tuple, or something more sophisticated like a NamedTuple, DataClass, or Class Is this a sequence? That is, do you need these items in order, or don't care about which one you get next, or will be dealing with all the items at once (even if one-by-one)? This is a list. Is this more of a "soup"? Where you want a specific item next, and don't care about order, or will be dealing with only specific objects at once? More on reddit.com

I doubt your problem stems from dict.get(). As u/RubyPinch pointed out, the two alternatives are quite similar.

You're setting the recursion limit to a million, the default is a thousand I believe. So I assume you're working with lots of data.

self.leader[self.current_source] = self.leader.get(self.current_source,[]) + [node]

creates a copy of self.leader[self.current_source](if it exists) every time it's executed. If that list is big, you've got a problem.

self.leader[self.current_source] += [node]

modifies the list in place.

More on reddit.com