{"id":2811,"date":"2021-06-13T10:55:37","date_gmt":"2021-06-13T14:55:37","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=2811"},"modified":"2022-12-19T11:22:12","modified_gmt":"2022-12-19T16:22:12","slug":"python-data-types","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/python-data-types-375510\/","title":{"rendered":"Python Data Types that Programmers Need To Master"},"content":{"rendered":"

At first glance, computer programming languages such as Python seem much less complex than natural human languages. If you’re reading this, that means that you’re more than capable of learning the fundamentals of Python! Especially since you’ve already survived years of remembering, applying, and practicing the use of countless grammar rules.<\/p>\n

Python Data types are very similar to any other language’s syntax structures: they are internal constructs that let you store and manipulate data in an orderly manner so your code can work (and be read) efficiently. However, there are complexities under the hood that aren’t readily apparent. In this article, we’ll cover some important aspects of Python data types to be aware of.<\/p>\n

Introduction<\/h2>\n

Data types in Python are organized in classes. Each class interacts with functions and operators differently, making it highly convenient to recognize each of them ahead of working on your code.<\/p>\n

Numeric Types, Sequence Types, Set types, Boolean Types, Dictionary types, (and even Binary Types!) make for all of Python’s Data types, and we’re excited to go through some of the most important ones with you today!<\/p>\n

Python Numeric Data Types<\/h2>\n

Python Numerical Data Types, as the word relates, represent numeric values. Numeric types cover Integers, Floats, and Complex numbers, allowing you to perform all sorts of calculations within Python.<\/p>\n

Integers<\/h3>\n

Integers, also known as ints, are Python’s “whole numbers only” numeric data class implemented as long<\/code> types of “arbitrary size<\/a>.” Whenever you type in a number without a decimal point in your code, Python’s interpreter reads it as an integer, no matter if it’s negative, positive, or a plain ol’ zero.<\/p>\n

The int<\/code> keyword also represents a built-in type conversion means via which developers can convert non-integer values to integer values with ease. In the case of decimal values (floating-point values) everything after the 1’s place gets dropped. Let’s see some integer values as they appear in Python:<\/p>\n

# create an integer\r\nx = 1\r\nprint(type(x), x)\r\n\r\n# create a floating point (decimal) value\r\ny = 1.0\r\nprint(type(x), x)\r\n\r\n# cast to an integer\r\ny = int(y)\r\nprint(type(y), y)\r\n\r\n# Output\r\n<class 'int'> 1\r\n<class 'int'> 1\r\n<class 'int'> 1<\/pre>\n
Here we see when the variable y<\/code>‘s value change from 1.0<\/code> to 1<\/code> when the int<\/code> function is used to cast it to an integer value. Also of note; many languages have a defined upper-limit for integer value data types.<\/p>\n
In Python, however, the int<\/code> data type is unbound and restricted only by the word type of the system on which it is used. In the case of 64-bit architectures (most modern computers) that provide an upper limit of 263<\/sup> – 1 = 9,223,372,036,854,775,807 values. For the curious, a system’s max integer size can be found by the sys.maxsize<\/code> property. Read here<\/a> for more detailed info on Python’s integers.<\/p>\n
Floats<\/h3>\n
Floating points, also known as floats, are Python’s decimal numbers and fraction numbers data class. Whenever you type in a number that has a decimal component in your code, Python’s interpreter reads it as a float. Just like integers, it doesn’t matter if its whole number component (numbers to the left of its decimal point) has a negative, positive, or even a 0 value.<\/p>\n
Integer values can easily be converted to floats either explicitly via a typecast such as float(1)<\/code> which results in the value 1.0<\/code> or implicitly by adding a float<\/code> value to an existing integer (even if that value is zero) as follows:<\/p>\n
# assign an integer value to x\r\nx = 1\r\nprint(type(x))\r\n\r\n# The result\r\n<class 'int'>\r\n\r\n# Add a decimal value to x\r\nx += 0.0\r\nprint(type(x), x)\r\n\r\n# the result is cast to a float\r\n<class 'float'> 1.0\r\n<\/pre>\n
Note<\/strong>: Floats can also be typed in with scientific notation<\/a> by just putting an “e” to the right of its last decimal value as a way to indicate the power of 10.<\/p>\n
Complex Numbers Data Type<\/h3>\n
In a nutshell, complex numbers are composed of a real and an imaginary part. Python comes with some impressive built-in support and modules that can help you tackle mathematical problems within your source code.
\nYou can define complex numbers using a literal form and the complex()<\/code> function.
\nThe literal form requires you to append the letter j<\/code> to the imaginary portion of your complex number, as follows:<\/p>\n
z = 3 + 2j<\/pre>\n
Alternatively, you can use the complex()<\/code> function to define your complex numbers. This function accepts two numeric parameters, with the first value representing the real part and the second parameter representing the imaginary part. Here’s an example:<\/p>\n
z = complex(3,2)<\/pre>\n
Notice that floating-point values can also be used to create complex numbers.<\/p>\n
z = 3.14 + 2.71j\r\ntype(z)\r\n<class 'complex'><\/pre>\n
Python and its Cmath module allow you to represent numbers in rectangular and polar coordinates, plot vectors, and even operate complex numbers in advanced arithmetic expressions. In our Python numbers piece, we’ve discussed Python complex numbers (and their most popular functions) in greater detail. Feel free to check it out!<\/span><\/p>\n
Remember<\/strong>: you can always apply Arithmetic Operators to all of Python\u2019s Numeric Types, allowing you to add, subtract, divide, multiply and exponentiate (and more<\/a>) depending on your coding needs.<\/span><\/p>\n
However, applying the same operators to other Data types such as Sequence Types and Binary Types will give you outputs that differ from a strictly mathematical one.<\/a><\/span><\/p>\n
Sequence Data Types<\/h2>\n
Python Sequence Data Types, as the word relates, allow you to store multiple values in an organized and efficient fashion. The primary Sequence Types cover Strings, Lists, Tuples, and Range (also called Range objects), making Data handling super easy and convenient.<\/p>\n
Strings<\/h3>\n
Strings represent textual data as immutable sequences of characters. By putting together a collection of characters within single, double (or even triple quotes), you can make an array of literal values, even if there are numbers inside the quotes!<\/p>\n
In Python, strings are marked with the str syntax. You can think of strings as a sequence of values whose elements are characters. For instance, let’s say we assign a sequence of characters (that are in between quotes) to a variable:<\/p>\n
a = \"hey dude\"\r\nprint(type(a))<\/pre>\n
If we call Python to print the type function of our variable \u201ca\u201d, the terminal will show:<\/p>\n
<class 'str'><\/pre>\n
Notice that Python also interprets each character within a string as a string in itself! If a string is a sequence of values, we can ask Python to specify each character based on its position within a string.<\/p>\n
We can do this by typing the variable to which our string is assigned and adding two closed brackets [ ]<\/code> with a number that relates to the position of each character within our string. We know this may sound like a mouthful, but the next couple of examples can show you what this all means: First, we assigned \"hey dude\"<\/code> value to our variable, then called this closed bracket operator.<\/p>\n
a = \"hey dude\" \r\nprint(a[0])<\/pre>\n
Once you run the program, the terminal shows:<\/p>\n
h<\/pre>\n
Python will then return the character stored in position 0 of our string. This process is known as indexing a string (more on that later!). Let’s try doing the same thing again progressively to see if Python can also give us the rest of the characters within our strings:<\/p>\n
a = \"hey dude\" \r\nprint(a[0])\r\nprint(a[1])\r\nprint(a[2])\r\nprint(a[3])\r\nprint(a[4])\r\nprint(a[5])\r\nprint(a[6])\r\nprint(a[7])<\/pre>\n
Once you run the program, the terminal shows:<\/p>\n
h\r\ne\r\ny\r\n\r\nd\r\nu\r\nd\r\ne<\/pre>\n
Python confirms that our string “Hey dude” is a sequence of characters that looks like ['h', 'e', 'y', '', 'd', 'u', 'd', 'e']<\/code>. Let’s also verify that each of the characters in our string is a string in itself by calling the type function on any of its characters:<\/p>\n
a = \"hey dude\" \r\nprint(type(a[3]))<\/pre>\n
Once you run the program, the terminal shows:<\/p>\n
<class 'str'><\/pre>\n
The return value tells us that the third character in our string (the space between the letter y and d in hey dude) is of class string. But what if we ask Python to give us the character next to that last \"e\"<\/code>, also known as a[8]<\/code>, in our string?<\/p>\n
a = \"hey dude\" \r\nprint(type(a[8]))<\/pre>\n
Once you run the program, the terminal shows:<\/p>\n
Traceback (most recent call last):\r\n  File \"<stdin>\", line 2, in <module>\r\nIndexError: string index out of range<\/pre>\n
Python returns an error value that looks pretty cryptic. But the important thing is to notice the phrase that comes after IndexError<\/code>. It spells string index out of range. This error teaches us that a string can only be as long as the number of characters that compose it. Thankfully, there’s a handy function that calculates the length of a string — the python len()<\/code> function. We can call this function the same way we apply the type function:<\/p>\n
a = \"hey dude\" \r\nprint(len(a))<\/pre>\n
Once you run the program, the terminal shows:<\/p>\n
8<\/pre>\n
Python returns an 8, effectively telling us that there are a total of 8 indexes within our string. The index ranged from 0 to 7, meaning that a[8]<\/code> was out of our string’s range. Likewise (and by this logic), if we order Python to print the a[-1]<\/code> index we see the following output:<\/p>\n
a=\"hey dude\"\r\nprint(a[-1])<\/pre>\n
Our terminal will show the same value as if we were printing the last index of our variable:<\/p>\n
e<\/pre>\n
This means that Python positioned itself on the first index [0]<\/code>, and went back one step back [-1]<\/code> on our string, printing the last \"e\"<\/code> of \"hey dude\"<\/code>. As you can imagine, this opens up a world of possibilities and interactions between data types and operators. We’ll go deeper on arithmetic and comparison operators and how to make the most out of each data type at a later time.<\/p>\n
The List Data Type<\/h2>\n
A list is a value that contains multiple values in an ordered sequence. The values contained within a list are called “items”, while the “list value” is the list itself.
\nIt’s important to distinguish this right from the get-go since lists can be stored in variables or passed to a function. This unique behavior turns lists into a fantastic data handling and organization tool. Here’s a quick example:<\/p>\n
test = ['keyboard', 'cpu', 'monitor', 'mouse']<\/pre>\n
We assigned the test<\/code> variable the list value. The list contains four items: keyboard, CPU, monitor, mouse<\/code>. Python also allows you to access items in a list, even if the list has been assigned to a variable. Let’s name our variable test<\/code>.<\/p>\n
For instance, if we typed test[0]<\/code> into our source code, we’d get the first item in our list (keyboard). The integer inside the brackets is what’s called an index. Each item in a list has its own index and can be evaluated in many ways. Our list’s items and corresponding index look something like this:<\/p>\n
\"data
Our “test” list example with its items and corresponding indexes.<\/figcaption><\/figure>\n
We can also evaluate test[3]<\/code> like this:<\/p>\n
test = ['keyboard', 'cpu', 'monitor', 'mouse']\r\nprint(test[3])\r\nmouse<\/pre>\n
You can also edit an item’s value by assigning values to its index. I’ll call on our original list and then edit it. We’ll change the monitor<\/code> item to mousepad<\/code> as follows:<\/p>\n
test = ['keyboard', 'cpu', 'monitor', 'mouse']\r\ntest[2] = \"mousepad\"<\/pre>\n
This updated version of our test<\/code> list now features mousepad<\/code> instead of monitor<\/code>.<\/p>\n
test = ['keyboard', 'cpu', 'monitor', 'mouse']\r\ntest[2] = \"mousepad\"\r\nprint(test)\r\n['keyboard', 'cpu', 'mousepad', 'mouse']<\/pre>\n
Quick disclaimer: the correct way to modify list values is through the delete command and append<\/code> method., which we’ll explore in a future article. The statements we previously used allows our variable to hold a new list value that includes mousepad<\/code> as a new item.<\/p>\n
This disclaimer will make sense once you’ve started using loops through a list in Python and learn how to pass list references. For now, treat this as a not-too-important footnote as you take your first steps into learning Python.<\/p>\n
Lists can also be concatenated, replicated, and much more. Some of its most basic yet powerful applications are combining Loops with Lists, finding specific values with the index()<\/code> method, and sorting them with the sort()<\/code> method.<\/p>\n
We’ll dive deeper into some of these powerful applications at a later time to keep things brief. Still, as you can already imagine, lists are incredibly powerful data handling tools with nearly endless possibilities.<\/p>\n
Tuple Data Type<\/h2>\n
A tuple shares some similarities with the list data type but features two critical differences:<\/p>\n
    \n
  1. Tuples are expressed with parentheses instead of square brackets.<\/li>\n
  2. Unlike Lists, Tuples are immutable. Its data cannot be modified, appended, or removed.<\/li>\n<\/ol>\n
    Here’s an example of a tuple:<\/p>\n
    tuple_example = ('7', 'seventy-seven', 'four', '5', 'eight', '9')<\/pre>\n
    Tuples are traditionally used to let others know that you don’t want that sequence of values to ever change. They see little use outside of this particular scenario but can be a handy resource when you’re collaborating with others.<\/p>\n
    Note: if you want to have a tuple with a single item, you need to add a comma after the value inside the parentheses.<\/p>\n
    The Range Data Type<\/h2>\n
    The range data type is one of Python’s most popular sequence data types. The range function can only be used within a loop to generate a sequence of numbers.<\/p>\n
    This function only accepts integers as values, so floating points cannot be part of a range function.<\/p>\n
    Range accepts up to three arguments. Each argument serves a specific purpose:<\/p>\n
    \"data
    Range function and its parameters.<\/figcaption><\/figure>\n
      \n
    1. Start: The function’s first argument (0 in this case) specifies the starting point in your series of numbers. If you don’t specify a starting point, Python will assume it’s 0.<\/li>\n
    2. Stop: the function’s second argument (5 in this case). It specifies where the series stops.<\/li>\n
    3. Step: the function’s third argument (1 in this case). This value represents the difference between one number and the next (if you don’t specify a step argument, Python will assume it’s 1).<\/li>\n<\/ol>\n
      Note: you can use positive numbers in the “step” portion of the function to increment a count or negative numbers to decrement it.<\/p>\n
      You can also call on the Range function using two arguments. Here’s an example:<\/p>\n
      for i in range (1,7):\r\n    print(i)\r\n\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6<\/pre>\n
      In this case, the number “1” serves as the starting point, while integer “7” represents the series’ stopping point. Notice that the series stops at 6 because the range function includes every number except for its “stop” value.<\/p>\n
      Last but not least, you can use the Range function using only one argument. Here’s an example:<\/p>\n
      for a in range (5):\r\n    print(a)\r\n\r\n0\r\n1\r\n2\r\n3\r\n4<\/pre>\n
      The integer 5 serves as the function’s stopping point. Python will automatically assume that the function’s starting point is “0” and its step value is “1”.<\/p>\n
      Binary Data Types in Python<\/h2>\n
      All our files, whether they’re videos, images, or text, are essentially zeroes and ones to our computers, which organize all of this data into bits.<\/p>\n
      From a more granular perspective, there are 8 bits in a byte. Each byte can store a sequence of values ranging from 0-255 that once initialized becomes immutable.<\/p>\n
      Bytes have a specific syntax and function in Python, as seen below.<\/p>\n
      Here’s how to use bytes(<size>):<\/p>\n
      >>> c = bytes(8)\r\n>>> c\r\nb'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\r\n>>>len(c)\r\n8<\/pre>\n
      The bytes in the embed above are empty, yet we cannot modify their value using this function. To do that, we need to turn to the bytearray<\/code> data type.<\/p>\n
      bytearray Data Type<\/h2>\n
      The bytearray<\/code> datatype turns bytes into a mutable sequence of integers<\/strong> ranging from 0 to 255. As seen below, you can append, overwrite, and remove elements to change the bytearray<\/code> object.<\/p>\n
      >>> arr = bytearray((0, 1, 2, 3))\r\n>>> arr[1]\r\n1\r\n\r\n>>> # The bytearray repr:\r\n>>> arr\r\nbytearray(b'\\x00\\x01\\x02\\x03')\r\n\r\n>>> # Bytearrays are mutable:\r\n>>> arr[1] = 23\r\n>>> arr\r\nbytearray(b'\\x00\\x17\\x02\\x03')\r\n\r\n>>> arr[1]\r\n23\r\n\r\n>>> # Bytearrays can grow and shrink in size:\r\n>>> del arr[1]\r\n>>> arr\r\nbytearray(b'\\x00\\x02\\x03')\r\n\r\n>>> arr.appendr(42)\r\n>>> arr\r\nbytearray(b'\\x00\\x02\\x03*')\r\n<\/pre>\n
      Note<\/strong>: Python shows the data inside each bit in hexadecimal values. In any case, if this seems a little bit cryptic, we recommend checking our piece on bytearrays<\/a> for some extra clarity<\/p>\n
      Python Memoryview Function<\/h2>\n
      Lastly, there is the memoryview<\/code> function, which allows you to safely access an object’s internal buffers. Keep in mind that memoryview<\/code> only read-only access to the object’s data; it can neither copy it nor modify it in any way.<\/p>\n
      This function is mostly used to peer into a large amount of data without copying its content, which could use up significant resources. The function’s syntax is as follows:<\/p>\n
      memoryview(obj)<\/pre>\n
      Binary data in Python is also used for Encoding, a topic that deserves a more nuanced explanation later. Through character encoding, computers can interpret, represent and send human-readable characters because they assign values to bytes and represent said characters.<\/p>\n
      Closing Words<\/h2>\n
      Code, just like human languages, uses different syntax structures and syntax rules to represent information. The key is to organize words in structures (like sentences and paragraphs) to convey ideas that everyone can read and understand.<\/p>\n
      In this article, we’ve taken a bird’s-eye look at some of the most important Python data types, covering some of the most basic functions and operators they have to offer. We highly recommend you check out each of our dedicated pieces to better understand how you can implement these wonderful resources into your own applications!<\/p>\n","protected":false},"excerpt":{"rendered":"
      At first glance, computer programming languages such as Python seem much less complex than natural human languages. If you’re reading this, that means that you’re more than capable of learning the fundamentals of Python! Especially since you’ve already survived years of remembering, applying, and practicing the use of countless grammar rules. Python Data types are […]<\/p>\n","protected":false},"author":4,"featured_media":2858,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[186,655],"tags":[302,28,143,363],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2811"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=2811"}],"version-history":[{"count":9,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2811\/revisions"}],"predecessor-version":[{"id":2864,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2811\/revisions\/2864"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/2858"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=2811"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=2811"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=2811"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}