Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://builtin.com/data-science/python-data-structures below:

What Are Python Data Structures? (Definition, Examples)

Python data structures are formats for organizing, storing and processing data in Python according to different types. There are four main types of built-in Python data structures: lists, tuples, sets and dictionaries.

1. Lists
2. Tuples
3. Sets
4. Dictionaries

A data structure is a way to organize data in computer memory so it can be easily accessed and used by computer programs. Every data structure has a specific format for organizing, processing, retrieving and storing data, allowing data to be manipulated in various ways by users and computer systems. Data structures are fundamental to modern software and programming languages. They can be built-in or user-defined, and range from basic to advanced types.

Built-in data structures are data structures supported by default in a programming language. They come with pre-defined syntax and behavior, and can be used without having to import additional libraries or modules. In Python, this includes data structures like lists, tuples, sets and dictionaries.

User-defined data structures are data structures created by users that aren’t supported natively in a programming language, but work to achieve similar functionality to existing programming concepts. A user-defined data structure can give users more control over data and how to manipulate it in a program, and may be implemented by importing additional libraries or modules. In Python, user-defined data structures can include arrays, stacks, queues, trees, linked lists, graphs and hash maps.

The four primary built-in data structures used in Python are lists, sets, tuples and dictionaries. 

Lists are a type of data structure containing an ordered collection of items. They are crucial to executing projects in Python. 

Each item in a list maintains its order, which can be used to access it by index. Lists are mutable, allowing elements to be searched, added, moved and deleted after creation. Lists can also be nested, allowing them to contain any object, including other lists and sublists.

#creating an empty list
my_list = []

#filling and printing the list
my_list = [1, 2, 3, 'abc', 1.5]
print(my_list)

#output: [1, 2, 3, 'abc', 1.5] 

Tuples are similar to lists but have more limited functionality because they are immutable. The primary difference between the two is that a tuple is immutable, meaning it cannot be modified or deleted once defined. Tuples are best when a user intends to keep an object intact throughout its lifetime to prevent the modification or addition of data.

#creating an empty tuple
my_tuple = ()

#filling and printing the tuple
my_tuple = (1, 2, 3, 'abc', 1.5)
print(my_tuple)

#output: (1, 2, 3, 'abc', 1.5)

A set is a collection of unique elements with no defined order, which are utilized when an object only needs to exist within a collection of objects and its order or number of appearances are not important.

#creating and printing a set
my_set = {1, 2, 3, 'abc', 1.5}
print(my_set)

#output of elements in the tuple is randomized, so it can vary every time the program is run 

Dictionaries are mutable collections that store data as key-value pairs, with keys required to be immutable.

#creating an empty dictionary
my_dict = {}

#filling and printing the dictionary
my_dict =	{
    'name': 'Bob',
    'occupation': 'Programmer',
    'start date': 1984
}

print(my_dict)

#using keys to access certain values
name = my_dict['name']
occupation = my_dict['occupation']

#printing the key values
print(name, ',', occupation)

#output:
{'name': 'Bob', 'occupation': 'Programmer', 'start date': 1984}
Bob , Programmer

User-defined data structures add additional functionality to Python, thereby allowing users to access, modify or preserve data in specific ways. In addition to Python’s built-in data structures, there are a number of user-defined data structures you can use, such as arrays, stacks, queues, trees and more. Many of these user-defined data structures can also be considered advanced Python data structures, since they have functionality that extends beyond the basic data structures included in Python.

• Arrays: Arrays function similarly to lists, but allow only homogeneous elements to be stored within them, whereas lists may contain heterogeneous elements.
• Stacks: Stacks are linear data structures in which the last element added is the first to be accessed (Last-In-First-Out or LIFO).
• Queues: Queues follow the First-In-First-Out (FIFO) principle, where the first element added is the first to be removed.
• Trees: Trees are non-linear data structures that incorporate roots and nodes to create a hierarchy of data. These structures are used heavily on HTML pages.
• Linked lists: Linked lists are abstract data structures where data is organized in nodes that link to each other in a list-like format. They can be efficient when needing to insert, find or remove items, in comparison to regular arrays or lists.
• Binary search trees allow you to access, sort and delete data quickly while maintaining the sorted order of element s once retrieved. Despite these advantages, binary search trees can require a tedious amount of work to create and manage.

Related3 Ways to Write Pythonic Conditional Statements

Each data structure offers a different way of completing tasks such as sorting, inserting and finding, but efficiency depends on the situation.

No data structure is ultimately better than another, but using one for a task it is not designed to support may lead to longer workflows, or worse, skewed data. 

• Linked lists are purpose-built for inserting and deleting data but only offer sequential access to this data, which means searching and sorting can be problematic.
• Similar to a list, tuples can be used for outputting either an entire tuple or individual elements, but they use less memory space and do not allow sorting, adding, replacing or deleting elements once defined.
• Sets do not allow duplicate values or maintain order, which makes them ideal for membership testing but less suitable for ordered collections.
• Dictionaries allow data to be collected in key-value pairs, making them excellent for quick retrievals in unstructured documents, but are too limited to work with large amounts of tabular data.
• Arrays are easy to create and excellent for completing tasks that involve working with sequential data, but sorting, inserting and deleting items can shift positions for every item in the array.
• Stacks are excellent for adding or removing data that was last entered within the database, and queues are meant to add or remove data first entered in the data set, but if you want to pull an item from the middle of the set, you’ll benefit from using a different data structure. 

The 4 main built-in data structures in Python are:

1. Lists
2. Tuples
3. Sets
4. Dictionaries

Yes, Python is considered a good choice for learning about data structures and algorithms in programming. This is due to Python’s simple syntax and wide range of standard libraries available for working with data structures and data manipulation.

In Python, tuples are immutable objects and have a fixed length once defined, while lists are mutable objects and have a dynamic length once defined. Tuples also use less memory than lists, making them faster to generate or access.

In Python, use a set instead of a list when you need to store unique elements and when the order of items is unimportant. Sets are ideal for tasks like membership testing, eliminating duplicates and quickly checking if a value exists in a collection.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4