Tuples are data structures that are very similar to lists, but they can’t be modified. They can only be created. Tuples are so much like lists that you may wonder why Python bothers to include them. The reason is that tuples have important roles that can’t be efficiently filled by lists, as keys for dictionaries.
- Tuple basics
Creating a tuple is similar to creating a list: assign a sequence of values to a variable. A list is a sequence that is enclosed by [ and ]; a tuple is a sequence that is enclosed by ( and ). For example :
After a tuple is created, using it is so much like using a list that it’s easy to forget they’re different data types :
The main difference between tuples and lists is that tuples are immutable. An attempt to modify a tuple results in a confusing error message, which is Python’s way of saying it doesn’t know how to set an item in a tuple :
You can create tuples from existing ones by using the + and * operators :
A copy of a tuple can be made in any of the same ways as for lists :
Tuples themselves can’t be modified. But if they contain any mutable objects (for example, lists or dictionaries), these may be changed if they’re still assigned to their own variables. Tuples that contain mutable objects aren’t allowed as keys for dictionaries.
- One-element tuples need a comma
A small syntactical point is associated with using tuples. Because the square brackets used to enclose a list aren’t used elsewhere in Python, it’s clear that  means an empty list and  means a list with one element. The same thing isn’t true with the parentheses used to enclose tuples. Parentheses can also be used to group items in expressions in order to force a certain evaluation order. If we say (x + y) in a Python program, do we mean that x and y should be added and then put into a one-element tuple, or do we mean that the parentheses should be used to force x and y to be added, before any expressions to either side come into play?
This is only a problem for tuples with one element, because tuples with more than one element always include commas to separate the elements, and the commas tell Python the parentheses indicate a tuple, not a grouping. In the case of one-element tuples, Python requires that the element in the tuple be followed by a comma, to disambiguate the situation. In the case of zero-element (empty) tuples, there’s no problem. An empty set of parentheses must be a tuple, because it’s meaningless otherwise :
- Packing and unpacking tuples
As a convenience, Python permits tuples to appear on the left-hand side of an assignment operator, in which case variables in the tuple receive the corresponding values from the tuple on the right-hand side of the assignment operator. Here’s a simple example :
This can be written even more simply, because Python recognizes tuples in an assignment context even without the enclosing parentheses. The values on the right-hand side are packed into a tuple and then unpacked into the variables on the left-hand side :
This is a convenient way to swap values between variables. Instead of saying :
just say :
To make things even more convenient, Python 3 has an extended unpacking feature, allowing an element marked with a * to absorb any number elements not matching the other elements. Again, some examples will make this clearer :
Note that the starred element receives all the surplus items as a list, and that if there are no surplus elements, it receives an empty list. Packing and unpacking can be performed using list delimiters as well :
- Converting between lists and tuples
Tuples can be easily converted to lists with the list() function (which takes any sequence as an argument and produces a new list with the same elements as the original sequence). Similarly, lists can be converted to tuples with the tuple() function (which does the same thing but produces a new tuple instead of a new list) :
As an interesting side note, list() is a convenient way to break a string into characters :
This works because list() (and tuple()) apply to any Python sequence, and a string is just a sequence of characters.
A set in Python is an unordered collection of objects used in situations where membership and uniqueness in the set are main things you need to know about that object. Just as with dictionary keys, the items in a set must be immutable and hashable. This means that ints, floats, strings, and tuples can be members of a set, but lists, dictionaries, and sets themselves can’t.
- Set operations
In addition to the operations that apply to collections in general, like in, len, and being able to use a for loop to iterate over all of their elements, sets also have several set-specific operations :
You can create a set by using set on a sequence, like a list (1). When a sequence is made into a set, duplicates are removed (2). After creating a set using the set function, you can use add (3) and remove (4) to change the elements in the set. The in keyword is used to check for membership of an object in a set (5). You can also use | (6) to get the union, or combination, of two sets, & to get their intersection (7), and ^ (8) tofind their symmetric difference—that is, elements that are in one set or the other but not both.
These examples aren’t a complete listing of set operations but are enough to give you a good idea of how sets work. For more information, refer to the official Python documentation.
Because sets aren’t immutable and hashable, they can’t belong to other sets. To remedy that situation there is another set type, frozenset (by built-in frozenset()), which is just like a set but can’t be changed after creation. Because frozensets are immutable and hashable, they can be members of other sets :
* [Python 學習筆記] 起步走 : 內建型態與操作 (Tuple)
* [Python 學習筆記] 起步走 : 內建型態與操作 (集合)
- [ 英文學習 ]
- [ 計算機概論 ]
- [ 深入雲計算 ]
- [ 雜七雜八 ]
- [ Algorithm in Java ]
- [ Data Structures with Java ]
- [ IR Class ]
- [ Java 文章收集 ]
- [ Java 代碼範本 ]
- [ Java 套件 ]
- [ JVM 應用 ]
- [ LFD Note ]
- [ MangoDB ]
- [ Math CC ]
- [ MongoDB ]
- [ MySQL 小學堂 ]
- [ Python 考題 ]
- [ Python 常見問題 ]
- [ Python 範例代碼 ]
- [C 常見考題]
- [C 範例代碼]
- [C/C++ 範例代碼]
- [Intro Alg]
- [Java 代碼範本]
- [Java 套件]
- [Linux 小技巧]
- [Linux 小學堂]
- [Linux 命令]
- [ML In Action]
- [Python 學習筆記]
- [Quick Python]
- [Software Engineering]
- [The python tutorial]
- ActiveMQ In Action
- Big Data 研究
- Design Pattern
- Device Driver Programming
- Docker 工具
- Docker Practice
- English Writing
- ExtJS 3.x
- Git Pro
- Hadoop. Hadoop Ecosystem
- Java Framework
- Java UI
- Learn Spark
- ML Udemy
- node js
- Python Std Library
- Python tools
- Ruby Packages
- Windows 技巧
Source From Here Preface I‘m trying to run the following command: # ssh firstname.lastname@example.org sudo command1 /path/to/file But, a...
來源自 這裡 前言 : Thread 是 threading 模塊中最重要的類之一，可以使用它來創建線程。有兩種方式來創建線程：一種是通過繼承Thread 類，重寫它的 run 方法；另一種是創建一個 threading.Thread 對象，在它的初始化...
Preface: 在這個階層中，我們只需考慮電路模組的功能，而不需考慮其硬體的詳細內容. Verilog 的時序控制為以事件為基礎的時序控制: * 接線或暫存器的值被改變。 * 模組的輸入埠接收到新的值 * 正規...
Source From Here Preface 本文實例講述了Python中 zip() 函數的定義及用法，相信對於Python初學者有一定的借鑒價值。 一、定義： zip([iterable, ...]) zip() 是 Python 的一個內建...