Kiểu dữ liệu list có khá nhiều phương thức để xử lý. Sau đây là tất cả các cách ấy:

mở rộng danh sách bằng cách thêm tất cả các phần tử từ iterable. Tương tự `a[len(a):] = iterable`.`list.insert`\(_i_, _x_\)

You might have noticed that methods like `insert`, `remove` or `sort` that only modify the list have no return value printed – they return the default `None`. [\[1\]](https://docs.python.org/3/tutorial/datastructures.html#id3) This is a design principle for all mutable data structures in Python.

The list methods make it very easy to use a list as a stack, where the last element added is the first element retrieved \(“last-in, first-out”\). To add an item to the top of the stack, use `append()`. To retrieve an item from the top of the stack, use `pop()` without an explicit index. For example:>>>

It is also possible to use a list as a queue, where the first element added is the first element retrieved \(“first-in, first-out”\); however, lists are not efficient for this purpose. While appends and pops from the end of list are fast, doing inserts or pops from the beginning of a list is slow \(because all of the other elements have to be shifted by one\).

List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.

The initial expression in a list comprehension can be any arbitrary expression, including another list comprehension.

See [Unpacking Argument Lists](https://docs.python.org/3/tutorial/controlflow.html#tut-unpacking-arguments) for details on the asterisk in this line.

There is a way to remove an item from a list given its index instead of its value: the [`del`](https://docs.python.org/3/reference/simple_stmts.html#del) statement. This differs from the `pop()` method which returns a value. The [`del`](https://docs.python.org/3/reference/simple_stmts.html#del) statement can also be used to remove slices from a list or clear the entire list \(which we did earlier by assignment of an empty list to the slice\). For example:>>>

Referencing the name `a` hereafter is an error \(at least until another value is assigned to it\). We’ll find other uses for [`del`](https://docs.python.org/3/reference/simple_stmts.html#del) later.

We saw that lists and strings have many common properties, such as indexing and slicing operations. They are two examples of _sequence_ data types \(see [Sequence Types — list, tuple, range](https://docs.python.org/3/library/stdtypes.html#typesseq)\). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the_tuple_.

This is called, appropriately enough, _sequence unpacking_ and works for any sequence on the right-hand side. Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.

Python also includes a data type for _sets_. A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.

Another useful data type built into Python is the _dictionary_ \(see [Mapping Types — dict](https://docs.python.org/3/library/stdtypes.html#typesmapping)\). Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”. Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by _keys_, which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like `append()`and `extend()`.

When looping through dictionaries, the key and corresponding value can be retrieved at the same time using the `items()` method.>>>

The conditions used in `while` and `if` statements can contain any operators, not just comparisons.

Note that in Python, unlike C, assignment cannot occur inside expressions. C programmers may grumble about this, but it avoids a common class of problems encountered in C programs: typing `=` in an expression when `==`was intended.

Sequence objects may be compared to other objects with the same sequence type. The comparison uses _lexicographical_ ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted. If two items to be compared are themselves sequences of the same type, the lexicographical comparison is carried out recursively. If all items of two sequences compare equal, the sequences are considered equal. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller \(lesser\) one. Lexicographical ordering for strings uses the Unicode code point number to order individual characters. Some examples of comparisons between sequences of the same type:

If you quit from the Python interpreter and enter it again, the definitions you have made \(functions and variables\) are lost. Therefore, if you want to write a somewhat longer program, you are better off using a text editor to prepare the input for the interpreter and running it with that file as input instead. This is known as creating a _script_. As your program gets longer, you may want to split it into several files for easier maintenance. You may also want to use a handy function that you’ve written in several programs without copying its definition into each program.

There are several ways to present the output of a program; data can be printed in a human-readable form, or written to a file for future use. This chapter will discuss some of the possibilities.