Welcome to the fourteenth chapter of our python tutorial course. In the last lesson, we looked at sets and operations done to sets, including union and intersection. In this tutorial, we'll take a closer look at lists and tuples to see how they're used. Python's most versatile and useful data types are lists and tuples. A non-trivial Python application will nearly always have these.
Lists and tuples have a number of significant features that you'll learn about. In this course, you'll understand the definitions and applications of these terms. By the time you're done, you'll know when and how to employ different Python object kinds.
In other words, Lists are similar to arrays in many other programming languages because they allow you to store any number of arbitrary elements within them. For a list to exist in Python, an object sequence must be enclosed in square brackets ([]) as seen in the example below:
In other words, a list is more than a collection of things. Collections of things are organized in this way. Lists are defined by the order in which their elements are listed, and this order is maintained throughout the life of the list itself. For more information on Python data types, check the dictionaries tutorial (coming soon).
A comparison of two lists that contain the same contents but are organized differently is impossible:
A list can be made up of any number of items. A list can have all of its elements of the same type:
Different kinds of elements can be used.
Complex objects such as functions, classes, and modules can also reside in lists, as you'll see in forthcoming tutorials:
From 0 to the limit of your computer's RAM, a list can contain any number of items.
Uniqueness isn't required for list objects. There is no limit to the number of times an object can be listed:
This is a question you could ask yourself whenever you need to access items in a list, and the answer is yes: an index in square brackets can be used to access items in a list. In other words, it's the same as looking up individual characters in a string. As with strings, the indexing of lists is zero-based. The following is a sample list:
Here are the indices for the items in a:
Slicing is another option. For lists, the formula a[m:n] retrieves only the part of a that is between m and but not containing n in the list a.
As you learned before, an item in a list can be of any type. Another list is included in that. You can have as many sublists as you want within a single list.
As an illustration, consider the following (obviously fabricated) scenario:
x refers to an item structure depicted in the image below:
These three strings below, are all one character in length:
Example of sublists are shown below:
Simply add an additional index to have access to the items in a sublist:
To the degree that your computer's RAM allows, there is no limit to the depth or complexity of nested lists in this manner.
A lot of your experience so far has been with atomic data types. Primitive units, such as integers and floats, are those that cannot be decomposed further. Once they've been allocated, these types aren't able to be modified. Changing the value of an integer doesn't make sense at all. If you prefer a different integer, simply change the one you've assigned.
The string type, on the other hand, is a complex type. Strings can be broken down into their constituent characters. Think of a string of characters and how they might be rearranged. However, this is not possible. Strings are also immutable in Python.
This is the first time you've met a mutable data type, the list. It is possible to add or remove items from a list at any time after it has been created. Lists can be modified in a variety of ways in Python.
A single value can be replaced in a list using indexing and simple assignment.
A string can't be used to accomplish this, as demonstrated in the Python tutorial Strings and Character Data.
In order to remove a list item, use the del command:
Suppose you'd like to change several neighboring items in a list at the same time. The following Python syntax for a slice assignment makes this possible.
Consider an iterable list at this point. iterable is substituted for the slice of a specified here:
It's not necessary to have the same number of new elements as the number of old ones. Python simply increases or decreases the list based on the task at hand. Utilize a slice which only refers to one element when you wish to replace a single element with multiple ones:
You can also add items to a list without having to remove anything from the original list. Simply type [n:n] to produce a zero-length slice at the requested index.
You can remove a large number of items from a list by assigning the correct slice to an empty list. It is possible to use the del statement with the same slice:
To add more items to the beginning or end of a list, you can use the + concatenation operator or the += augmented assignment operator:
For example, a singleton list can only have one item in it, hence, it must be added to a different list:
Python provides a number of built-in methods for modifying lists. Below, you'll find more information on these methods. The target string was not directly modified in the previous tutorial's string methods. Strings are immutable, so this is why. String methods, on the other hand, give you back a completely rewritten string object. They don't change the target string at all:
List methods differ from other approaches. Lists are changeable, therefore the target list gets modified while the list method is running.
Adds a new item to the end of a collection.
List functions change the target list on the fly. They don't give you a new one:
Adds items from an iterable to a list.
Yes, it's most likely what you're expecting. Additionally, an iterable is required as an argument to extend(). iterable> elements are inserted one at a time:
To put it another way, extend() functions similarly to the plus sign (+). Because it alters the list while it's still in place, it's equivalent to the += operator:
A new element is added to a collection with the help of this method. Object obj> is inserted into the list an at the index indicated by insert(index>, obj>). It's a[index>] obj, and the remaining list items are moved rightward after the function call.
In a list, this function removes one item. remove(<obj>) list an is cleared of obj. An exception is thrown if obj> is not in a:
In a list, this function removes one item. There are two key differences between this method and remove():
The last item in the list is simply removed by calling pop():
Specifying an index in the optional index parameter causes this command to remove and return the given item. Like string and list indexing, index can be negative.
Python lists are described in this course by a set of six qualities. Finally, lists can be reordered. Sections above have shown many instances of this. A list expands as new things are added:
Similarly, as things are removed from a list, the list gets smaller.
A tuple is a collection of things that are arranged in a specific order. When it comes to the pronunciation of a word or phrase, it depends on who you ask. A few people say it as if it were spelled "too-ple," while others pronounce it as "tup-ple," which rhymes with "supple." Because everyone I know pronounces "supple," "quintuple," "sextuple," and "octuple" as though they rhyme with "supple," my preference is for the latter.
Lists and tuples are nearly identical, with the exception of the following characteristics:
As an illustration of tuples in action, consider the following code sample:
There's no need to worry! Reversing a tuple is as simple as using our usual string and list reversal process:
It's important to remember that although though tuples are constructed using parenthesis, you still use square brackets to index and slice them.
A tuple is a list with the same properties as a list: it's ordered, it can include arbitrary objects; it's indexable and sliceable; and it can be nestable like any other list. However, they cannot be changed:
There is a way to display the values of several objects at once in a Python REPL session by simply inserting them one after the other between commas:
Because Python interprets the input as a tuple, it presents the response in parentheses. The definition of a tuple has a peculiarity that you should know about. It's impossible to be vague when creating a tuple that has no items or a tuple with two or more. A tuple is defined in Python:
Because parentheses are used to denote operator precedence in expressions, the expression (2) creates an int object. Before closing parentheses, you need to put in an extra comma (,): This tells Python that you plan to create a single tuple.
There has to be a mechanism to define a singleton tuple, even if you don't need to do it very often.
Using Python, you can display a singleton tuple by putting a comma in front of it:
You've seen this before: a literal tuple can be allocated to a single object.
When this happens, it's as if the tuple's contents have been "stuffed" into the object:
"packed" objects can be "unpacked" into a new tuple by assigning them to the new tuple's objects.
Otherwise, a problem will emerge when unpacking a tuple: if there are more variables than values, an error will occur.
Compound assignments can be created by combining the steps of packing and unpacking into a single expression.
It's important to remember that in this tuple, the components on the left and right must be equal.
It is possible to leave off the parentheses required to denote a tuple in Python assignments like this one and a few others:
If you're unsure whether or not the parentheses are necessary, go ahead and put them in if you have any doubt. Python idioms are made possible by multiple assignment. As a programmer, it is common to have two variables whose values must be swapped. While the swap is taking place, a temporary variable must be used to store one of the values.
In Python, a simple tuple assignment is all that is needed to perform a swap:
If you have ever used a Python temporary variable to exchange values, this is the pinnacle of modern technology. It's the greatest it's ever going to be.
Congratulations! You have now completed the list and tuple tutorial. Python lists and tuples were introduced, along with some of their basic features and operations. In Python, you'll be relying on these all the time. It is a list's primary property that it is organized. It is impossible to modify the order of a list's elements, unless, of course, the list is altered. The same is true for tuples, except that they can't be updated. Python's conditional statements will be covered in the upcoming lesson.
JLCPCB – Prototype 10 PCBs for $2 (For Any Color)
China’s Largest PCB Prototype Enterprise, 600,000+ Customers & 10,000+ Online Orders Daily
How to Get PCB Cash Coupon from JLCPCB: https://bit.ly/2GMCH9w
