What is the difference between tuples and lists in python

1. Lists are dynamic arrays, they are immutable and can be reset in length (change the number of elements inside them);

2. Tuples are static arrays, they are immutable, and their internal data cannot be changed once created;

3. Tuples are cached in the Python runtime environment, which means that we don't need to access the kernel to allocate memory every time we use tuples.

Recommended tutorials: Python tutorials The above is to share the detailed content about the difference between tuples and lists in python, I hope it will be helpful to you, for more python tutorials, please pay attention to other related articles of Global Ivy League!

First, the nature is different.

1. Tuples. tuple) is a relational database.

, a relationship is a table, each row in the table (i.e., each record in the database) is a tuple, and each column is an attribute. In a two-dimensional table, tuples are also called rows.

2. List: A form of ** as a container, loaded with text or charts, called a list.

2. The application of parentheses is different.

1. Tuple declarations use parentheses.

2. Use square brackets for the list.

When declaring a tuple with only one element, you need to add a comma to the end of the element.

Third, the operation process is different.

1. After the tuple is declared and assigned, elements cannot be added, deleted or modified like a list, that is to say, the tuple cannot be modified during the operation of the rental program.

2. After the list is declared and assigned, elements can be added, deleted, and modified.

Fourth, the application method is different.

1. Tuple: The main operations applicable to tuple hail are tuple merging, traversing, finding the maximum and minimum values of tuples, and other operation methods.

2. List: suitable for sorting, replacing, adding, etc.

tuples. In fact, the gap with the list is not very big, but it also has its own independent characteristics:

A tuple is a series of immutable Python objects. A tuple is a sequence, just like a list; Lists are often used to store the same type of data; Tuples, on the other hand, are often used to store different types of data in actual development.

The main difference between tuples and lists is that tuples cannot change the value of an element in the same way that a list does, and can be simply understood as a "read-only list". Tuples use parentheses - (while lists use square brackets.)

Tuple creation is as simple as adding elements in parentheses and separating them with commas.

Create a tuple: A sequence of values separated by commas and brackets is placed. Alternatively, you can put these comma-separated values between parentheses.

Access to tuple elements: Use square brackets to specify index slices or indexes to get the values that are discreet for that index.

Change tuples: Tuples are immutable, but you can use part of an existing tuple to create a new tuple.

Delete tuple elements: Element values in a tuple are not allowed to be deleted, but we can use del statements to delete the entire tuple.

Python tuples build simple compositions of objects, tuples are very similar to lists, but tuples cannot be modified in situ, are usually written as a series of items wrapped in parentheses, and have most of the properties of a list.

A tuple is: an ordered collection of arbitrary objects: and strings.

Similar to a list, a tuple is a location-based, ordered collection of objects that can be embedded in any type of object.

By offset.

Access: Like strings and lists, elements in tuples are accessed by offsets, supporting indexes and sharding.

Belongs to an Immutable Sequence: Like strings, tuples are immutable and do not support any in-place modification operations that apply to lists.

Fixed length, diversity, arbitrary nesting: Tuples are immutable, so the tuple length cannot be changed, and tuples can contain compound objects and support arbitrary nesting.

Array of object references: Like a list, a tuple is an array of object references that stores access points to other objects.

<> tuple is a type of data type that can be indexed to a list in a single way.

Difference Between List and Tuple:

The first difference is that the declaration of a tuple uses parentheses, while the list uses square brackets, and when declaring a tuple with only one element, you need to add a comma after this element; The second difference is that once a tuple is declared and assigned, elements cannot be added, removed, or modified like a list, i.e. the tuple cannot be modified while the program is running.

The design philosophy of the two differs: a list can be used to hold a collection of data for multiple objects that hail from each other, and a tuple can be used to describe multiple properties of a transaction that does not change.

In python, for example, the usage of tuples:

A tuple is also a sequence. tuples are defined using parentheses "(); The elements in the tuple are separated by commas. Tuples do not support modifying or deleting the rock elements they contain.

If you want to modify it, you can use the list function to convert it into a list, and then modify it on the list to create a tuple in three ways:

1. Use parentheses "() to create, for example, a (1,2,3).

2. Use a comma to create, for example, b 2,4.

3. Use the tuple0 function to convert other kinds of sequences into tuples, for example, c tuple("good! ”）

The first thing we need to understand is that tuples and lists belong to sequences, which are a set of elements stored in a specific order, and can be created and deleted in the same way as certificates, real numbers, strings, lists, tuples, dictionaries, collections, and any other type of content.

So what's the difference? The main points are as follows:

1. The list is dynamic and belongs to a mutable sequence, and elements can be added, modified, and deleted, while tuples are static and belong to an immutable sequence, and elements cannot be added, deleted, or modified unless replaced as a whole.

2. The list can use append(), extend(), insert(), remove() and pop() to add and modify list elements, while the tuple does not have these methods, because the elements cannot be added and modified to the tuple, and similarly, the elements cannot be deleted, and can be replaced as a whole.

3. The list can use slices to access and modify the elements in the list, and the tuple also supports slicing, but it only supports accessing the elements in the tuple through slices, and does not support modification.

4. Tuples are faster to access and process than lists, so if you only need to access the elements in them without making any modifications, it is recommended to use tuples instead of lists.

5. Because the list can be modified, the tuple cannot be modified, so the tuple has higher security than the list.

6. A list cannot be used as a key in a dictionary, while a tuple can.

7. The storage method is different: an empty list occupies 16 bytes more than an empty tuple.

List and tuple are Python's built-in sorted sets, one mutable and one immutable. Choose to use them as needed.

1. Tuples are immutable, while lists are mutable.

2. Tuples usually have different data types, while lists are data queues of the same type. Tuples represent structure, while lists represent order.

3. You can't use a list as a dictionary key, but a tuple can4. Because a tuple supports smaller operations than a list, a tuple will be slightly faster than a list. However, if it is not for massive data processing, this difference is basically negligible.