When first learning Python, you might not immediately notice how important data structures and algorithms are to the language. In fact, Python has several built-in data structures that are used to store and manipulate data. Because of this, it’s important to have at least an understanding of what they are and how they work in order to make your code more effective and efficient, while still being easy to read and maintainable by others on your team.
What is a Python data structure?
A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently. It is a blueprint for how data is stored, with specifications on how to access, insert, update, delete or retrieve it. In Python, there are many different kinds of data structures; here are some examples: Lists (or arrays) - perhaps you’ve heard of these before. They’re simply ordered lists of values; they can be indexed numerically or by using keys that refer to unique values within the list. Dictionary (sometimes called hash tables) - these are unordered collections of key-value pairs that can be looked up quickly based on keys alone. Sets - these are unordered collections of unique items that cannot contain duplicates. Tuples - these are groups of related values that may or may not have a fixed order. Sets and tuples do not allow any indexing; their elements must be accessed by iterating over them one at a time, e.g., set[0] , set[1] , etc., or tuple[0] , tuple[1] , etc.
List vs. set
The list data structure is a dynamic array of items, each identified by an index. Lists have no predefined maximum size; however, accessing or modifying an item at an index beyond the end of a list generates a runtime error. The set data structure includes only unique items, and does not include any duplicate entries as duplicates are by definition non-unique. Set values are unordered and cannot be accessed directly; instead you use methods to query for membership or inclusion status (e.g., is item X contained within set Y?). In Python, sets are implemented using hash tables with comparisons between members done using their hash value. Sets provide fast lookup times because they do not need to contain their members sequentially; there is no requirement that elements must be added in order or that items may only appear once per set. In addition, sets allow efficient checking for inclusion because there is no need to loop through all members of a collection if multiple checks will always return False (or True).
Loops & Iterators
Loops are a fundamental feature of almost every programming language. Almost any task you perform regularly (like displaying data to a user or clearing an array) can be accomplished with loops. Iterators are objects that automatically loop through data structures (lists, arrays, maps) for you. They’re more efficient than manually looping through data structures yourself because they don’t create as many objects along the way. If you want to be efficient, use iterators! However, they aren’t always available, so it's good to know how to do things without them. Also, some languages don't have iterators at all. For example: Python doesn't have them! This is why knowing how algorithms work is important: if you're not using Python 3+ then there's no need for you to learn about it. In fact, there are tons of tasks where manual iteration is faster than using an iterator anyway. It's important to know when each method is appropriate so that you're not wasting time trying to make something work when it won't ever happen efficiently anyway.
Sorting & Searching
Without mastering these two things, you won’t be able to program well in any language. So if you haven’t done so already, take some time to study up on how data structures and algorithms work. Once you have a firm grasp of them, it will make learning other languages a lot easier. If you want to see how they work together, check out my tutorial on sorting data structures in Python. In that post, I go over how to use arrays, lists, tuples and dictionaries for sorting purposes. After that I dive into binary search trees (the red-headed stepchild of searching), hash tables (dictionaries), heaps (last-in first-out) and graphs (adjacency lists). In addition to showing how all these various data structures are used for searching purposes, I also provide links to detailed tutorials about each one. Check it out!
Methods are key
In Python, everything is an object. All variables are objects that contain attributes, as well as methods. That means data structures (and code blocks) can have their own code within them, which we call methods. To access a method we just call it: a = [1, 2] - This assigns an empty list to a; then you can use that list by calling its append method, like so: b = a.append(3) This adds 3 to your original list of 1 and 2! Another way you might use methods is to create more advanced lists: c = [1] d = c.extend([2]) This creates two new lists linked together – d contains every item from c except for 1, which has been overwritten by 2.