{"id":453,"date":"2025-05-20T04:46:19","date_gmt":"2025-05-20T04:46:19","guid":{"rendered":"https:\/\/buhave.com\/courses\/?p=453"},"modified":"2025-05-20T12:56:49","modified_gmt":"2025-05-20T12:56:49","slug":"data-structures","status":"publish","type":"post","link":"https:\/\/buhave.com\/courses\/python\/data-structures\/","title":{"rendered":"Data Structures"},"content":{"rendered":"

Lists and list methods
\n<\/span><\/h2>\n

What Are Lists in Python?<\/h3>\n

A list is a built-in data structure in Python that is used to store multiple items in a single variable. Lists are ordered, mutable, and can contain elements of mixed data types (strings, numbers, booleans, other lists, etc.).<\/p>\n

List Syntax<\/strong><\/p>\n

my_list = [1, 2, 3, “hello”, True]<\/em><\/p>\n

    \n
  • Items are separated by commas.<\/li>\n
  • Enclosed in square brackets [].<\/li>\n
  • Indexed starting from 0.<\/li>\n<\/ul>\n

    Accessing List Items<\/strong><\/p>\n

    fruits = [“apple”, “banana”, “cherry”]<\/em>
    \nprint(fruits[0]) # Output: apple<\/em>
    \nprint(fruits[-1]) # Output: cherry (negative index = from end)<\/em><\/p>\n

    Common List Methods<\/strong><\/p>\n

    Python provides many built-in methods to manipulate lists:<\/p>\n

    append(item)<\/strong><\/p>\n

    Adds a new item to the end of the list.<\/p>\n

    fruits.append(“orange”)<\/em><\/p>\n

    insert(index, item)<\/strong><\/p>\n

    Inserts an item at a specific position.<\/p>\n

    fruits.insert(1, “kiwi”) # Inserts “kiwi” at index 1<\/em><\/p>\n

    extend(iterable)<\/strong><\/p>\n

    Extends the list by appending elements from another iterable (like another list).<\/p>\n

    fruits.extend([“mango”, “grape”])<\/em><\/p>\n

    remove(item)<\/strong><\/p>\n

    Removes the first occurrence of the specified value.<\/p>\n

    fruits.remove(“banana”)<\/em><\/p>\n

    pop([index])<\/strong><\/p>\n

    Removes and returns the item at the given index (or last item if no index is given).<\/p>\n

    last_fruit = fruits.pop() # Removes last item<\/em><\/p>\n

    clear()<\/strong><\/p>\n

    Removes all items from the list.<\/p>\n

    fruits.clear()<\/em><\/p>\n

    index(item)<\/strong><\/p>\n

    Returns the index of the first occurrence of the specified item.<\/p>\n

    idx = fruits.index(“apple”)<\/em><\/p>\n

    count(item)<\/strong><\/p>\n

    Returns the number of times a value appears in the list.<\/p>\n

    nums = [1, 2, 2, 3, 2]<\/em>
    \nprint(nums.count(2)) # Output: 3<\/em><\/p>\n

    sort()<\/strong><\/p>\n

    Sorts the list in-place (modifies the original list). For ascending order by default.<\/p>\n

    numbers = [4, 2, 9, 1]<\/em>
    \nnumbers.sort()<\/em><\/p>\n

    Use numbers.sort(reverse=True) for descending.<\/p>\n

    sorted(list)<\/strong><\/p>\n

    Returns a new sorted list without modifying the original.<\/p>\n

    sorted_numbers = sorted(numbers)<\/em><\/p>\n

    reverse()<\/strong><\/p>\n

    Reverses the elements of the list in-place.<\/p>\n

    numbers.reverse()<\/em><\/p>\n

    copy()<\/strong><\/p>\n

    Creates a shallow copy of the list.<\/p>\n

    new_list = fruits.copy()<\/em><\/p>\n

    Looping Through Lists:<\/strong><\/p>\n

    for fruit in fruits:<\/em>
    \nprint(fruit)<\/em><\/p>\n

    List Slicing<\/strong><\/p>\n

    nums = [0, 1, 2, 3, 4, 5]<\/em>
    \nprint(nums[1:4]) # Output: [1, 2, 3]<\/em>
    \nprint(nums[:3]) # Output: [0, 1, 2]<\/em>
    \nprint(nums[::2]) # Output: [0, 2, 4]<\/em><\/p>\n

    Lists Are Mutable<\/strong><\/p>\n

    You can modify individual items:<\/p>\n

    nums[0] = 100<\/em><\/p>\n

    And delete with del:<\/p>\n

    del nums[2]<\/em><\/p>\n

    Summary<\/strong><\/p>\n

      \n
    • Lists are ordered, mutable, and can hold mixed data types.<\/li>\n
    • Access items using indexes.<\/li>\n
    • Modify lists with built-in methods like append(), remove(), sort(), and more.<\/li>\n
    • Use slicing, loops, and comprehensions for powerful list operations.<\/li>\n<\/ul>\n

      Tuples and tuple unpacking<\/h2>\n

      What Are Tuples?<\/h3>\n

      A tuple is a built-in data type in Python used to store multiple items in a single, ordered, immutable collection.<\/p>\n

        \n
      • Like a list, but cannot be changed (immutable) after creation.<\/li>\n
      • Often used for fixed data (e.g., coordinates, RGB colors, function returns).<\/li>\n<\/ul>\n

        Tuple Syntax<\/strong><\/p>\n

        my_tuple = (1, 2, 3)<\/em><\/p>\n

          \n
        • Defined with parentheses () \u2014 although parentheses are optional.<\/li>\n
        • Elements separated by commas.<\/li>\n
        • Can hold mixed data types.<\/li>\n<\/ul>\n

          One-item tuple (very important!)<\/strong><\/p>\n

          To define a tuple with one item, you must include a comma:<\/p>\n

          single = (5,) # This is a tuple<\/em>
          \nnot_a_tuple = (5) # This is just an int<\/em><\/p>\n

          Accessing Tuple Elements<\/strong><\/p>\n

          Tuples are indexed, just like lists:<\/p>\n

          colors = (“red”, “green”, “blue”)<\/em>
          \nprint(colors[0]) # red<\/em>
          \nprint(colors[-1]) # blue<\/em><\/p>\n

          Looping Through Tuples<\/strong><\/p>\n

          for color in colors:<\/em>
          \nprint(color)<\/em><\/p>\n

          Tuples Are Immutable<\/strong><\/p>\n

          You cannot change, add, or remove items from a tuple:<\/p>\n

          colors[0] = “yellow” #\u00a0 TypeError<\/em><\/p>\n

          Tuple Methods<\/h3>\n
            \n
          • Tuples have fewer methods than lists due to immutability:<\/li>\n
          • count(value) \u2013 returns the number of times a value appears.<\/li>\n
          • index(value) \u2013 returns the index of the first matching value.<\/li>\n<\/ul>\n

            nums = (1, 2, 2, 3)<\/em>
            \nprint(nums.count(2)) # 2<\/em>
            \nprint(nums.index(3)) # 3<\/em><\/p>\n

            Tuple Unpacking<\/h3>\n

            Tuple unpacking lets you assign values from a tuple to multiple variables in one line.<\/p>\n

            Basic Unpacking<\/strong><\/p>\n

            point = (10, 20)<\/em>
            \nx, y = point<\/em>
            \nprint(x) # 10 <\/em>print(y) # 20<\/em><\/p>\n

            The number of variables must match the number of tuple items.<\/p>\n

            Swapping Variables (Pythonic Way)<\/strong><\/p>\n

            a = 5<\/em>
            \nb = 10<\/em>
            \na, b = b, a<\/em>
            \nprint(a, b) # Output: 10 5<\/em><\/p>\n

            No need for a temporary variable!<\/p>\n

            Unpacking with * (Extended Unpacking)<\/strong><\/p>\n

            a, *b = (1, 2, 3, 4)<\/em>
            \nprint(a) # 1<\/em>
            \nprint(b) # [2, 3, 4]<\/em><\/p>\n

            a, *b, c = (1, 2, 3, 4, 5)<\/em>
            \nprint(a) # 1<\/em>
            \nprint(b) # [2, 3, 4]<\/em>
            \nprint(c) # 5<\/em><\/p>\n

            Tuple Unpacking in Functions<\/strong><\/p>\n

            You can return multiple values from a function using a tuple:<\/p>\n

            def get_user():<\/em>
            \nreturn “Alice”, 30 # returns a tuple<\/em><\/p>\n

            name, age = get_user()<\/em>
            \nprint(name) # Alice<\/em>
            \nprint(age) # 30<\/em><\/p>\n

            Summary:<\/strong><\/p>\n

              \n
            • Tuples are ordered, immutable sequences.<\/li>\n
            • Useful for fixed data or function returns.<\/li>\n
            • Use tuple unpacking to assign values in a clean way.<\/li>\n
            • Tuples support indexing, looping, and limited methods (count(), index()).<\/li>\n<\/ul>\n

              Dictionaries and dictionary methods<\/h2>\n

              What Is a Dictionary?<\/h3>\n

              A dictionary is a collection of key-value pairs, where each key is unique, and each key maps to a specific value. Think of it like a real dictionary: each word (key) has a definition (value).<\/p>\n

              Dictionary Syntax<\/strong><\/p>\n

              my_dict = {<\/em>
              \n“name”: “Alice”,<\/em>
              \n“age”: 30,<\/em>
              \n“is_active”: True<\/em>
              \n}<\/em><\/p>\n

                \n
              • Keys and values are separated by colons.<\/li>\n
              • Pairs are separated by commas.<\/li>\n
              • Enclosed in curly braces {}.<\/li>\n<\/ul>\n

                Accessing Values<\/strong><\/p>\n

                print(my_dict[“name”]) # Output: Alice<\/em><\/p>\n

                Use the key to access the value.<\/p>\n

                Using get() Method<\/strong><\/p>\n

                print(my_dict.get(“name”)) # Alice<\/em>
                \nprint(my_dict.get(“email”, “N\/A”)) # N\/A if key not found<\/em><\/p>\n

                Safer than bracket access because it avoids KeyError.<\/p>\n

                Adding & Updating Items<\/strong><\/p>\n

                my_dict[“email”] = “alice@example.com” # Add new<\/em>
                \nmy_dict[“age”] = 31 # Update existing<\/em><\/p>\n

                Removing Items<\/strong><\/p>\n

                my_dict.pop(“age”) # Removes and returns the value for ‘age’<\/em>
                \ndel my_dict[“is_active”] # Removes key ‘is_active’<\/em><\/p>\n

                Clearing the Dictionary<\/strong><\/p>\n

                my_dict.clear() # Removes all items<\/em><\/p>\n

                Dictionary Methods<\/strong><\/p>\n

                Here are some of the most commonly used dictionary methods:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n
                Method<\/strong><\/th>\nDescription<\/strong><\/th>\n<\/tr>\n<\/thead>\n
                get(key, default)<\/code><\/td>\nReturns value for key, or default if key not found<\/td>\n<\/tr>\n
                keys()<\/code><\/td>\nReturns a view object of all keys<\/td>\n<\/tr>\n
                values()<\/code><\/td>\nReturns a view object of all values<\/td>\n<\/tr>\n
                items()<\/code><\/td>\nReturns a view object of (key, value) pairs<\/td>\n<\/tr>\n
                update(dict2)<\/code><\/td>\nMerges dictionary with another dictionary’s key-value pairs<\/td>\n<\/tr>\n
                pop(key)<\/code><\/td>\nRemoves and returns the item with the specified key<\/td>\n<\/tr>\n
                popitem()<\/code><\/td>\nRemoves and returns the last inserted (key, value) pair<\/td>\n<\/tr>\n
                clear()<\/code><\/td>\nRemoves all items from the dictionary<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                Example:<\/strong> Looping Through a Dictionary<\/p>\n

                for key in my_dict:<\/em>
                \nprint(key, my_dict[key])<\/em><\/p>\n

                Or with .items()<\/strong><\/p>\n

                for key, value in my_dict.items():<\/em>
                \nprint(f”{key}: {value}”)<\/em><\/p>\n

                Check If a Key Exists<\/strong><\/p>\n

                if “name” in my_dict:<\/em>
                \nprint(“Found name”)<\/em><\/p>\n

                Dictionary Comprehensions<\/strong><\/p>\n

                squares = {x: x**2 for x in range(5)}<\/em>
                \nprint(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}<\/em><\/p>\n

                Nesting Dictionaries<\/strong><\/p>\n

                users = {<\/em>
                \n“alice”: {“age”: 25, “email”: “a@example.com”},<\/em>
                \n“bob”: {“age”: 30, “email”: “b@example.com”}<\/em>
                \n}<\/em>
                \nprint(users[“bob”][“email”]) # b@example.com<\/em><\/p>\n

                Summary:<\/strong><\/p>\n

                  \n
                • Dictionaries store key-value pairs and are unordered (but maintain insertion order in Python 3.7+).<\/li>\n
                • Keys must be immutable and unique (e.g., strings, numbers, tuples).<\/li>\n
                • Use methods like .get(), .items(), .update(), and .pop() to work with them efficiently.<\/li>\n
                • Great for representing structured data, such as JSON, configurations, and more.<\/li>\n<\/ul>\n

                  Sets and set operations<\/h2>\n

                  What Is a Set in Python?<\/h3>\n

                  A set is an unordered, mutable, and unindexed collection of unique elements. Sets are great when you need to eliminate duplicates or perform set-based logic.<\/p>\n

                  Set Syntax<\/strong><\/p>\n

                  my_set = {1, 2, 3, 4}<\/em><\/p>\n

                    \n
                  • Use curly braces {} or the set() constructor.<\/li>\n
                  • Duplicate values are automatically removed.<\/li>\n<\/ul>\n

                    Creating an empty set must use set() \u2014 {} creates an empty dictionary, not a set.<\/p>\n

                    empty_set = set()<\/em><\/p>\n

                    Example:<\/strong> Duplicates Removed Automatically<\/p>\n

                    nums = {1, 2, 2, 3, 3}<\/em>
                    \nprint(nums) # Output: {1, 2, 3}<\/em><\/p>\n

                    Common Set Methods<\/strong><\/p>\n\n\n\n\n\n\n\n\n\n\n\n
                    Method<\/th>\nDescription<\/th>\n<\/tr>\n<\/thead>\n
                    add(item)<\/code><\/td>\nAdds a single item to the set<\/td>\n<\/tr>\n
                    update(iterable)<\/code><\/td>\nAdds multiple items from an iterable<\/td>\n<\/tr>\n
                    remove(item)<\/code><\/td>\nRemoves the specified item (raises KeyError if item doesn’t exist)<\/td>\n<\/tr>\n
                    discard(item)<\/code><\/td>\nRemoves the specified item (does nothing if item doesn’t exist)<\/td>\n<\/tr>\n
                    pop()<\/code><\/td>\nRemoves and returns an arbitrary item from the set (raises KeyError if empty)<\/td>\n<\/tr>\n
                    clear()<\/code><\/td>\nRemoves all items from the set<\/td>\n<\/tr>\n
                    copy()<\/code><\/td>\nReturns a new set with a shallow copy of the elements<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                    Example Methods:<\/strong><\/p>\n

                    s = {1, 2, 3}<\/em>
                    \ns.add(4) # {1, 2, 3, 4}<\/em>
                    \ns.update([5, 6]) # {1, 2, 3, 4, 5, 6}<\/em>
                    \ns.remove(3) # {1, 2, 4, 5, 6}<\/em>
                    \ns.discard(10) # No error if 10 isn’t there<\/em><\/p>\n

                    Looping Through a Set<\/strong><\/p>\n

                    for item in s:<\/em>
                    \nprint(item)<\/em><\/p>\n

                    Order is not guaranteed in sets.<\/p>\n

                    Set Operations (like in Math)<\/strong><\/p>\n

                    union() or |<\/strong><\/p>\n

                    Combine all unique elements from both sets.<\/p>\n

                    a = {1, 2, 3}<\/em>
                    \nb = {3, 4, 5}<\/em>
                    \nprint(a | b) # {1, 2, 3, 4, 5}<\/em>
                    \nprint(a.union(b)) # Same<\/em><\/p>\n

                    intersection() or &<\/strong><\/p>\n

                    Get only the elements common to both sets.<\/p>\n

                    print(a & b) # {3}<\/em>
                    \nprint(a.intersection(b)) # Same<\/em><\/p>\n

                    difference() or –<\/strong><\/p>\n

                    Get elements that are in the first set but not in the second.<\/p>\n

                    print(a – b) # {1, 2}<\/em>
                    \nprint(a.difference(b)) # Same<\/em><\/p>\n

                    symmetric_difference() or ^<\/strong><\/p>\n

                    Get elements in either set, but not both.<\/p>\n

                    print(a ^ b) # {1, 2, 4, 5}<\/em>
                    \nprint(a.symmetric_difference(b)) # Same<\/em><\/p>\n

                    Set Comparisons<\/strong><\/p>\n\n\n\n\n\n\n\n\n
                    Operation<\/strong><\/th>\nMeaning<\/strong><\/th>\nExample<\/strong><\/th>\n<\/tr>\n<\/thead>\n
                    ==<\/code><\/td>\nSets contain exactly the same elements<\/td>\n{1, 2} == {2, 1}<\/code> \u2192 True<\/code><\/td>\n<\/tr>\n
                    issubset()<\/code><\/td>\nAll elements of set A exist in set B<\/td>\n{1, 2}.issubset({1, 2, 3})<\/code> \u2192 True<\/code><\/td>\n<\/tr>\n
                    issuperset()<\/code><\/td>\nAll elements of set B exist in set A<\/td>\n{1, 2, 3}.issuperset({1, 2})<\/code> \u2192 True<\/code><\/td>\n<\/tr>\n
                    isdisjoint()<\/code><\/td>\nSets share no common elements<\/td>\n{1, 2}.isdisjoint({3, 4})<\/code> \u2192 True<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                    Example:<\/strong><\/p>\n

                    a = {1, 2}<\/em>
                    \nb = {1, 2, 3}<\/em><\/p>\n

                    print(a.issubset(b)) # True<\/em>
                    \nprint(b.issuperset(a)) # True<\/em>
                    \nprint(a.isdisjoint({4})) # True<\/em><\/p>\n

                    Summary:<\/strong><\/p>\n

                      \n
                    • Sets store unique, unordered values.<\/li>\n
                    • Use sets to remove duplicates and perform mathematical operations.<\/li>\n
                    • Built-in methods like union(), intersection(), and difference() make sets powerful for logic and data comparisons.<\/li>\n<\/ul>\n

                      Want to learn about frozensets (immutable sets), set comprehensions, or use cases like duplicates removal in lists? Just let me know!<\/p>\n","protected":false},"excerpt":{"rendered":"

                      Lists and list methods What Are Lists in Python? A list is a built-in data structure in Python that is used to store multiple items in a single variable. Lists are ordered, mutable, and can contain elements of mixed data types (strings, numbers, booleans, other<\/p>\n","protected":false},"author":1,"featured_media":454,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[9],"tags":[],"class_list":["post-453","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python"],"yoast_head":"\nData Structures - Python Course<\/title>\n<meta name=\"description\" content=\"Data structures help organize and manage collections of values efficiently for processing, retrieval, and manipulation in programs.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/buhave.com\/courses\/python\/data-structures\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Data Structures - Python Course\" \/>\n<meta property=\"og:description\" content=\"Data structures help organize and manage collections of values efficiently for processing, retrieval, and manipulation in programs.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/buhave.com\/courses\/python\/data-structures\/\" \/>\n<meta property=\"og:site_name\" content=\"BUHAVE\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/BeYouHave\/\" \/>\n<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/naveedsafdarawan\/\" \/>\n<meta property=\"article:published_time\" content=\"2025-05-20T04:46:19+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-05-20T12:56:49+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Data-Structures.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"Naveed Safdar\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Naveed Safdar\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/\"},\"author\":{\"name\":\"Naveed Safdar\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#\\\/schema\\\/person\\\/04fe0254e118521c9fbb3da39de5acca\"},\"headline\":\"Data Structures\",\"datePublished\":\"2025-05-20T04:46:19+00:00\",\"dateModified\":\"2025-05-20T12:56:49+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/\"},\"wordCount\":1419,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/Data-Structures.webp\",\"articleSection\":[\"Python Course\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/\",\"name\":\"Data Structures - Python Course\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/Data-Structures.webp\",\"datePublished\":\"2025-05-20T04:46:19+00:00\",\"dateModified\":\"2025-05-20T12:56:49+00:00\",\"description\":\"Data structures help organize and manage collections of values efficiently for processing, retrieval, and manipulation in programs.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/#primaryimage\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/Data-Structures.webp\",\"contentUrl\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/Data-Structures.webp\",\"width\":1200,\"height\":628,\"caption\":\"Data Structures\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/data-structures\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Courses\",\"item\":\"https:\\\/\\\/buhave.com\\\/courses\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Python Course\",\"item\":\"https:\\\/\\\/buhave.com\\\/courses\\\/learn\\\/python\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Data Structures\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#website\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/\",\"name\":\"BUHAVE\",\"description\":\"Courses - Learn Online for Free\",\"publisher\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/buhave.com\\\/courses\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#organization\",\"name\":\"BUHAVE\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/03\\\/buhave-course.webp\",\"contentUrl\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/03\\\/buhave-course.webp\",\"width\":375,\"height\":75,\"caption\":\"BUHAVE\"},\"image\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/BeYouHave\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/buhave\",\"https:\\\/\\\/www.youtube.com\\\/@buhave\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#\\\/schema\\\/person\\\/04fe0254e118521c9fbb3da39de5acca\",\"name\":\"Naveed Safdar\",\"description\":\"I\u2019m Naveed Safdar - SEO Manager with over 10 years of experience in SEO and Digital Marketing. I\u2019ve had the privilege of working with leading national and international companies including Grafdom, PakWheels, Systems Limited, Confiz, Educative, and Dubizzle Labs. My expertise spans technical SEO, content strategy, organic growth, and performance analytics - helping businesses improve visibility, traffic, and ROI.\",\"sameAs\":[\"https:\\\/\\\/www.linkedin.com\\\/in\\\/naveedsafdar\\\/\",\"https:\\\/\\\/www.facebook.com\\\/naveedsafdarawan\\\/\",\"https:\\\/\\\/www.youtube.com\\\/@naveedsafdar\"],\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/author\\\/naveed-safdar\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Data Structures - Python Course","description":"Data structures help organize and manage collections of values efficiently for processing, retrieval, and manipulation in programs.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/buhave.com\/courses\/python\/data-structures\/","og_locale":"en_US","og_type":"article","og_title":"Data Structures - Python Course","og_description":"Data structures help organize and manage collections of values efficiently for processing, retrieval, and manipulation in programs.","og_url":"https:\/\/buhave.com\/courses\/python\/data-structures\/","og_site_name":"BUHAVE","article_publisher":"https:\/\/www.facebook.com\/BeYouHave\/","article_author":"https:\/\/www.facebook.com\/naveedsafdarawan\/","article_published_time":"2025-05-20T04:46:19+00:00","article_modified_time":"2025-05-20T12:56:49+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Data-Structures.webp","type":"image\/webp"}],"author":"Naveed Safdar","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Naveed Safdar","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/#article","isPartOf":{"@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/"},"author":{"name":"Naveed Safdar","@id":"https:\/\/buhave.com\/courses\/#\/schema\/person\/04fe0254e118521c9fbb3da39de5acca"},"headline":"Data Structures","datePublished":"2025-05-20T04:46:19+00:00","dateModified":"2025-05-20T12:56:49+00:00","mainEntityOfPage":{"@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/"},"wordCount":1419,"commentCount":0,"publisher":{"@id":"https:\/\/buhave.com\/courses\/#organization"},"image":{"@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/#primaryimage"},"thumbnailUrl":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Data-Structures.webp","articleSection":["Python Course"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/buhave.com\/courses\/python\/data-structures\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/","url":"https:\/\/buhave.com\/courses\/python\/data-structures\/","name":"Data Structures - Python Course","isPartOf":{"@id":"https:\/\/buhave.com\/courses\/#website"},"primaryImageOfPage":{"@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/#primaryimage"},"image":{"@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/#primaryimage"},"thumbnailUrl":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Data-Structures.webp","datePublished":"2025-05-20T04:46:19+00:00","dateModified":"2025-05-20T12:56:49+00:00","description":"Data structures help organize and manage collections of values efficiently for processing, retrieval, and manipulation in programs.","breadcrumb":{"@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/buhave.com\/courses\/python\/data-structures\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/#primaryimage","url":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Data-Structures.webp","contentUrl":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Data-Structures.webp","width":1200,"height":628,"caption":"Data Structures"},{"@type":"BreadcrumbList","@id":"https:\/\/buhave.com\/courses\/python\/data-structures\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Courses","item":"https:\/\/buhave.com\/courses\/"},{"@type":"ListItem","position":2,"name":"Python Course","item":"https:\/\/buhave.com\/courses\/learn\/python\/"},{"@type":"ListItem","position":3,"name":"Data Structures"}]},{"@type":"WebSite","@id":"https:\/\/buhave.com\/courses\/#website","url":"https:\/\/buhave.com\/courses\/","name":"BUHAVE","description":"Courses - Learn Online for Free","publisher":{"@id":"https:\/\/buhave.com\/courses\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/buhave.com\/courses\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/buhave.com\/courses\/#organization","name":"BUHAVE","url":"https:\/\/buhave.com\/courses\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/buhave.com\/courses\/#\/schema\/logo\/image\/","url":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/03\/buhave-course.webp","contentUrl":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/03\/buhave-course.webp","width":375,"height":75,"caption":"BUHAVE"},"image":{"@id":"https:\/\/buhave.com\/courses\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/BeYouHave\/","https:\/\/www.linkedin.com\/company\/buhave","https:\/\/www.youtube.com\/@buhave"]},{"@type":"Person","@id":"https:\/\/buhave.com\/courses\/#\/schema\/person\/04fe0254e118521c9fbb3da39de5acca","name":"Naveed Safdar","description":"I\u2019m Naveed Safdar - SEO Manager with over 10 years of experience in SEO and Digital Marketing. I\u2019ve had the privilege of working with leading national and international companies including Grafdom, PakWheels, Systems Limited, Confiz, Educative, and Dubizzle Labs. My expertise spans technical SEO, content strategy, organic growth, and performance analytics - helping businesses improve visibility, traffic, and ROI.","sameAs":["https:\/\/www.linkedin.com\/in\/naveedsafdar\/","https:\/\/www.facebook.com\/naveedsafdarawan\/","https:\/\/www.youtube.com\/@naveedsafdar"],"url":"https:\/\/buhave.com\/courses\/author\/naveed-safdar\/"}]}},"_links":{"self":[{"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/posts\/453","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/comments?post=453"}],"version-history":[{"count":1,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/posts\/453\/revisions"}],"predecessor-version":[{"id":455,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/posts\/453\/revisions\/455"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/media\/454"}],"wp:attachment":[{"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/media?parent=453"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/categories?post=453"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/tags?post=453"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}