Python-列表元组字典集合

介绍

Python 序列（Sequence）是指按特定顺序依次排列的一组数据，它们可以占用一块连续的内存，也可以分散到多块内存中。Python 中的序列类型包括列表（list）、元组（tuple）、字典（dict）和集合（set）。

在Python编程中，我们既需要独立的变量来保存一份数据，也需要序列来保存大量数据。列表（list）和元组（tuple）比较相似，它们都按顺序保存元素，所有的元素占用一块连续的内存，每个元素都有自己的索引，因此列表和元组的元素都可以通过索引（index）来访问。它们的区别在于：列表是可以修改的，而元组是不可修改的。

字典（dict）和集合（set）存储的数据都是无序的，每份元素占用不同的内存，其中字典元素以 key-value的形式保存

Python序列详解（包括序列类型和常用操作）

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。集合和字典不支持索引、切片、相加和相乘操作。

字符串也是一种常见的序列，它也可以直接通过索引访问字符串内的字符。

序列索引

序列中，每个元素都有属于自己的编号（索引）。从起始元素开始，索引值从 0 开始递增，如图1所示。

图1 序列索引值示意图

Python还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 2 所示。

图2 负值索引示意图

注意，在使用负值作为列序中各元素的索引值时，是从 -1 开始，而不是从 0 开始。

序列切片

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。
语法格式：sname[start : end : step]

其中，各个参数的含义如下：

• sname：表示序列的名称；
• start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
• end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
• step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果step的值大于1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置step的值，则最后一个冒号就可以省略。

  >>> str = "Hello World"
  >>> print(str[:2])
  He
  >>> print(str[::2])
  HloWrd
  >>> print(str[:])
  Hello World
  

  序列相加

  Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。

  这里所说的“类型相同”，指的是“+”运算符的两侧序列要么都是序列类型，要么都是元组类型，要么都是字符串。

  序列相乘

  Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复n次的结果。

  >> print(str*3)
  Hello WorldHello WorldHello World
  

  检查元素是否包含在序列中

  Python 中，可以使用 in 关键字检查某元素是否为序列的成员，其语法格式为：
  value in sequence 其中，value 表示要检查的元素，sequence 表示指定的序列。

与in关键字用法相同，但功能恰好相反的，还有not in关键字，它用法检查某个元素是否不包含在指定的序列中

>>> print('W' in str)
True
>>> print('W' not in str)
False

序列相关的内置函数

Python提供了几个内置函数，可用于实现与序列相关的一些常用操作，如下表：
| 函数 | 功能 |
| —————- | ———————————————————————————————————————————————————————————————————————————————————————————————————- |
| len() | 计算序列的长度，即返回序列中包含多少个元素。 |
| max() | 找出序列中的最大元素。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。 |
| min() | 找出序列中的最小元素 |
| list() | 将序列转换为列表 |
| str() | 将序列转换为字符串。 |
| sum() | 计算元素和。 |
| sorted() | 对元素进行排序。 |
| reversed() | 反向序列中的元素。 |
| enumerate() | 将序列组合为一个索引序列，多用在 for 循环中。 |

Python list列表详解

列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同

在使用列表时，虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。

Python创建列表

在 Python 中，创建列表的方法可分为两种：

1.使用[]直接创建列表
使用[ ]创建列表后，一般使用=将它赋值给某个变量，具体格式如下：

listname = [element1 , element2 , element3 , … , elementn]

其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

2.使用list()函数创建列表

Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。例如：

>>> list1 = list('hello')
>>> print(list1)
['h', 'e', 'l', 'l', 'o']
>>> dict1 = {'a':100, 'b':42, 'c':9}
>>> list2 = list(dict1)
>>> print(list2)
['a', 'b', 'c']

访问列表元素

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

listname[i] #索引访问
listname[start:end:step] # 切片访问

删除列表

对于已经创建的列表，如果不再使用，可以使用del关键字将其删除。Python自带的垃圾回收机制会自动销毁无用的列表，即使不手动删除，Python也会自动将其回收。
语法格式：del listname

Python list列表添加元素

append()添加元素

append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：
listname.append(obj)

其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

>>> l = ['python','c++','java']
>>> l.append('php')
>>> l
['python', 'c++', 'java', 'php']
>>> l.append(['Ruby','SQL'])
>>> l
['python', 'c++', 'java', 'php', ['Ruby', 'SQL']]

extend()方法添加元素

extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。语法格式如下：

listname.extend(obj)

>> t = ('JS', 'C#', 'Go')
>> l.extend(t)
>> print(l)
['python', 'c++', 'java', 'php', ['Ruby', 'SQL'], 'JS', 'C#', 'Go']

insert()方法插入元素

append()和extend()方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert()方法。语法格式：
listname.insert(index, obj)

其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。

>>> l = ['Python', 'C++', 'Java']
>>> l
['Python', 'C++', 'Java']
>>> l.insert(1, 'C')
>>> l
['Python', 'C', 'C++', 'Java']
>>> l.insert(3, ['Ruby', 'SQL'])
>>> l
['Python', 'C', 'C++', ['Ruby', 'SQL'], 'Java']

list列表删除元素(4种方法)

在 Python 列表中删除元素主要分为以下 3 种场景：

• 根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
• 根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
• 将列表中所有元素全部删除，可使用列表（list类型）提供的clear()方法。

  del:根据索引值删除元素

  del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。语法格式如下：

  del listname[index] # index表示索引
  del listname[start:end] # 中间一段连续的元素

  pop():根据索引值删除元素

  用于删除列表中指定索引处的元素，语法格式：
  listname.pop(index) #类似于数据结构中的“出栈”操作。

  >> nums = [40,36,89,2,36,100,7]
  >> nums.pop(3)
  2
  >> nums.pop()
  7
  >> print(nums)
  [40, 36, 89, 36, 100]
  

  remove():根据元素值进行删除

  remove()方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发ValueError错误。使用 remove() 删除元素时最好提前判断一下。

clear():删除列表所有元素

用来删除列表的所有元素，也即清空列表。

list列表修改元素

Python提供了两种修改列表（list）元素的方法，你可以每次修改单个元素，也可以每次修改一组元素（多个）。

修改单个元素

修改单个元素非常简单，直接对元素赋值即可。实例如下：

>>> nums = [40,36,89,2,36,100,7]
>>> nums[2] = -26
>>> nums[-3] = 66.22
>>> print(nums)
[40, 36, -26, 2, 66.22, 100, 7]

修改一组元素

Python支持通过切片语法给一组元素赋值。在进行这种操作时，如果不指定步长（step 参数），Python就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素。

>>> nums = [40,36,89,2,36,100,7]
>>> nums[1:4] = [45,25, -77, -52.5]
>>> print(nums)
[40, 45, 25, -77, -52.5, 36, 100, 7]
# 对空切片(slice)赋值，相当于插入一组新元素
>>> nums = [40,36,89,2,36,100,7]
>>> nums[4:4] = [-77, -52.5, 999]
>>> print(nums)
[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]
# 使用切片语法赋值时，Python 不支持单个值

list列表查找元素

Python 列表（list）提供了index()和count()方法，它们都可以用来查找元素。

index()方法

index()方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致ValueError错误，所以在查找之前最好使用count()方法判断一下。语法格式：

listname.index(obj, start, end)

其中，listname表示列表名称，obj 表示要查找的元素，start表示起始位置，end表示结束位置。start和end参数用来指定检索范围：

• start和end可以都不写，此时会检索整个列表；
• 如果只写start不写end，那么表示检索从start到末尾的元素；
• 如果start和end都写，那么表示检索 start 和 end 之间的元素。

index()方法会返回元素所在列表中的索引值。示例如下：

[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]
>>> print(nums.index(100,3,))
8
>>> print(nums.index(55))
Traceback (most recent call last):
  File "", line 1, in 
ValueError: 55 is not in list

count()方法

count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：

listname.count(obj)

如果count()返回 0，就表示列表中不存在该元素，所以count()也可以用来判断列表中的某个元素是否存在。

Python tuple元组

元组和列表（list）的不同之处在于：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
• 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

  语法格式：(element1, element2, … , elementn)

  创建元组

  1.使用()直接创建

通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：

tuplename = (element1, element2, …, elementn)

需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。

2.使用tuple()函数创建
tuple() 的语法格式如下：

tuple(data)

访问元组

元素使用索引访问元组元素的格式为：
tuplename[i]

其中，tuplename 表示元组名字，i 表示索引值。元组的索引可以是正数，也可以是负数。

使用切片访问元组元素的格式为：

tuplename[start : end : step]

其中，start 表示起始索引，end 表示结束索引，step 表示步长。

修改元组

组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。

删除元组

使用del关键字删除元组

Python元组和列表的区别

元组和列表最大的区别就是，列表中的元素可以进行任意修改；而元组中的元素无法修改，除非将元组整体替换掉。tuple元组是只读版本的list。

>>> listdemo = []
>>> listdemo.__sizeof__()
40
>>> tupleDemo = ()
>>> tupleDemo.__sizeof__()
24

由于列表是动态的，它需要存储指针来指向对应的元素（占用 8 个字节）。另外，由于列表中元素可变，所以需要额外存储已经分配的长度大小（占用 8 个字节）。但是对于元组，情况就不同了，元组长度大小固定，且存储元素不可变，所以存储空间也是固定的。

元组要比列表更加轻量级，所以从总体上来说，元组的性能速度要由于列表。另外，Python 会在后台，对静态数据做一些资源缓存。通常来说，因为垃圾回收机制的存在，如果一些变量不被使用了，Python 就会回收它们所占用的内存，返还给操作系统，以便其他变量或其他应用使用。

但是对于一些静态变量（比如元组），如果它不被使用并且占用空间不大时，Python 会暂时缓存这部分内存。这样的话，当下次再创建同样大小的元组时，Python 就可以不用再向操作系统发出请求去寻找内存，而是可以直接分配之前缓存的内存空间，这样就能大大加快程序的运行速度。元组的不可替代性体现在以下这些场景中：

• 元组作为很多内置函数和序列类型方法的返回值存在，也就是说，在使用某些函数或者方法时，它的返回值会元组类型，因此你必须对元组进行处理。
• 元组比列表的访问和处理速度更快，因此，当需要对指定元素进行访问，且不涉及修改元素的操作时，建议使用元组。
• 元组可以在映射（和集合的成员）中当做“键”使用，而列表不行

  Python dict字典详解

  Python字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”。字典的主要特征如下表：
  | 主要特征 | 解释 |
  | ——————————————— | —————————————————————————————————————————————————————————————————————— |
  | 通过键而不是通过索引来读取元素 | 字典类型有时也称为关联数组或者散列表 （hash）。它是通过键将一系列的值联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获取。 |
  | 字典是任意数据类型的无序集合 | 和列表、元组不同，通常会将索引值 0 对应的元素称为第一个元素，而字典中的元素是无序的。 |
  | 字典是可变的，并且可以任意嵌套 | 字典可以在原处增长或者缩短（无需生成一个副本），并且它支持任意深度的嵌套，即字典存储的值也可以是列表或其它的字典。 |
  | 字典中的键必须唯一 | 字典中，不支持同一个键出现多次，否则只会保留最后一个键值对。 |
  | 字典中的键必须不可变 | 字典中的值是不可变的，只能使用数字、字符串或者元组，不能使用列表。 |

  Python创建字典

  1.使用{}创建字典

由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。语法格式如下：

dictname = {‘key’:’value1’, ‘key2’:’value2’,…,’keyn’:’vakyen’}

其中dictname表示字典变量名，keyn :valuen表示各个元素的键值对。需要注意的是，同一字典中的各个键必须唯一，不能重复。

>>> scores = {'数学': 95, '英语': 92, '语文': 84}
>>> print(scores)
{'数学': 95, '英语': 92, '语文': 84}
>>> dict1 = {(20, 30): 'great', 30: [1,2,3]}
>>> print(dict1)
{(20, 30): 'great', 30: [1, 2, 3]}

2.通过fromkeys()方法创建字典

使用dict字典类型提供的fromkeys()方法创建带有默认值的字典，具体格式为：

dictname = dict.fromkeys(list，value=None)

>> knowledge = {'语文', '数学', '英语'}
>> scores = dict.fromkeys(knowledge, 60)
>> scores
{'英语': 60, '数学': 60, '语文': 60}

3.通过dict()映射函数创建字典

创建格式	注意事项
a = dict(str1=value1, str2=value2, str3=value3)	str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号。
#方式1 demo = [(‘two’,2), (‘one’,1), (‘three’,3)]#方式2 demo = [[‘two’,2], [‘one’,1], [‘three’,3]]#方式3 demo = ((‘two’,2), (‘one’,1), (‘three’,3)) #方式4 demo = ([‘two’,2], [‘one’,1], [‘three’,3])	a = dict(demo) 向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值。
keys = [‘one’, ‘two’, ‘three’] #还可以是字符串或元组values = [1, 2, 3] #还可以是字符串或元组a = dict( zip(keys, values))	通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。

无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键。

访问字典

列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。Python访问字典元素的具体格式为：
dictname[key]

其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。

除了上面这种方式外，Python更推荐使用dict类型提供的get()方法来获取指定键对应的值。当指定的键不存在时，get()方法不会抛出异常。

>>> tup = (['two',26], ['one',88], ['three',100], ['four',-59])
>>> dic = dict(tup)
>>> print(dic['one'])  #键存在
88
>>> print(dic['five'])  #键不存在
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'five'
>>> a = dict(two=0.65, one=88, three=100, four=-59)
>>> print( a.get('one') )
88
>>> print( a.get('five', '该键不存在') )
该键不存在

Python dict字典基本操作（包括添加、修改、删除键值对）

由于字典属于可变序列，所以我们可以任意操作字典中的键值对（key-value）。Python 中，常见的字典操作有以下几种：

• 向现有字典中添加新的键值对。
• 修改现有字典中的键值对。
• 从现有字典中删除指定的键值对。
• 判断现有字典中是否存在指定的键值对。

  字典是由一个一个的key-value构成的，key是找到数据的关键，Python对字典的操作都是通过key来完成的。

  Python字典添加键值对

  字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：
  dictname[key] = value

对各个部分的说明：

• dictname表示字典名称。
• key表示新的键。
• value表示新的值，只要是Python支持的数据类型都可以。

  >>> a = {'数学':95}
  >>> print(a)
  {'数学': 95}
  >>> #添加新键值对
  ... a['语文'] = 89
  >>> print(a)
  {'数学': 95, '语文': 89}
  >>> #再次添加新键值对
  ... a['英语'] = 90
  >>> print(a)
  {'数学': 95, '语文': 89, '英语': 90}
  

  Python字典修改键值对

  Python 字典中键（key）的名字不能被修改，只能修改值（value）。字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。

  >>> a['语文'] = 100
  >>> print(a)
  {'数学': 95, '语文': 100, '英语': 90}
  

  Python字典删除键值对

  删除字典中的键值对，使用del语句，如下：

  >>> a = {'数学': 95, '语文': 89, '英语': 90}
  >>> del a['语文']
  >>> a
  {'数学': 95, '英语': 90}
  

  判断字典中是否存在指定键值对

  先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。

  需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。

  >> print('物理' in a)
  False
  

  keys、values()和items()方法

  它们都用来获取字典中的特定数据：

• keys() 方法用于返回字典中的所有键（key）；
• values()方法用于返回字典中所有键对应的值（value）；
• items()用于返回字典中所有的键值对（key-value）。

  >>> res = {'数学': 95, '语文': 89, '英语': 90}
  >>> print(res.keys())
  dict_keys(['数学', '语文', '英语'])
  >>> print(res.values())
  dict_values([95, 89, 90])
  >>> print(res.items())
  dict_items([('数学', 95), ('语文', 89), ('英语', 90)])
  >>> for k,v in res.items():
  ...     print("key:",k," value:",v)
  ... 
  key: 数学  value: 95
  key: 语文  value: 89
  key: 英语  value: 90
  

  copy()方法

  copy()方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典

  >>> a = {'one': 1, 'two': 2, 'three': [1,2,3]}
  >>> b = a.copy()
  >>> print(b)
  {'one': 1, 'two': 2, 'three': [1, 2, 3]}
  

  注意，copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝。拿拷贝字典a为例，copy()方法只会对最表层的键值对进行深拷贝，也就是说，它会再申请一块内存用来存放 {‘one’: 1, ‘two’: 2, ‘three’: []}；而对于某些列表类型的值来说，此方法对其做的是浅拷贝，也就是说，b 中的 [1,2,3] 的值不是自己独有，而是和a共有。

  >>> a = {'one': 1, 'two': 2, 'three': [1,2,3]}
  >>> b = a.copy()
  >>> a['four']=100
  >>> print(a)
  {'one': 1, 'two': 2, 'three': [1, 2, 3], 'four': 100}
  >>> print(b)
  {'one': 1, 'two': 2, 'three': [1, 2, 3]}
  >>> a['three'].remove(1)
  >>> print(a)
  {'one': 1, 'two': 2, 'three': [2, 3], 'four': 100}
  >>> print(b)
  {'one': 1, 'two': 2, 'three': [2, 3]}
  

  update()方法

  update() 方法可以使用一个字典所包含的键值对来更新己有的字典。

在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

>>> a = {'one': 1, 'two': 2, 'three': 3}
>>> a.update({'one':4.5, 'four':9.3})
>>> a
{'one': 4.5, 'two': 2, 'three': 3, 'four': 9.3}

pop()hepopitem()方法

pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对，它们的语法格式如下：

dictname.pop(key) \
dictname.popitem()

>> a = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}>>> print(a)
{'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
>> a.pop('化学')
83
>> print(a)
{'数学': 95, '语文': 89, '英语': 90, '生物': 98, '物理': 89}
>> a.popitem()
('物理', 89)
>> print(a)
{'数学': 95, '语文': 89, '英语': 90, '生物': 98}

键值对在底层也是有存储顺序的，popitem() 总是弹出底层中的最后一个 key-value

setdefault()方法

setdefault()方法用来返回某个key对应的value，其语法格式如下：

dictname.setdefault(key, defaultvalue)

>> a = {'数学': 95, '语文': 89, '英语': 90}
>> print(a)
{'数学': 95, '语文': 89, '英语': 90}
>> #key不存在，指定默认值
... a.setdefault('物理', 94)
94
>> print(a)
{'数学': 95, '语文': 89, '英语': 90, '物理': 94}
>> #key不存在，不指定默认值
... a.setdefault('化学')
>> print(a)
{'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None}
>> #key存在，指定默认值
... a.setdefault('数学', 100)
95
>> print(a)
{'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None}

使用字典格式化字符串

在字符串模板中按 key 指定变量，然后通过字典为字符串模板中的 key 设置值。举例如下：

>> temp = '教程是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s'
>> book = {'name':'Python基础教程', 'price': 99, 'publish': 'C语言中文网'}
>> print(temp % book)
教程是:Python基础教程, 价格是:0000099.00, 出版社是:C语言中文网

Python set集合详解

Python 中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：
{element1,element2,…,elementn}

同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型。数据必须保证是唯一的，因为集合对于每种数据元素，只会保留一份。 Python 中的 set 集合是无序的，所以每次输出时元素的排序顺序可能都不相同。

其实，Python 中有两种集合类型，一种是set类型的集合，另一种是 frozenset类型的集合，它们唯一的区别是，set类型集合可以做添加、删除元素的操作，而forzenset类型集合不行。

创建set集合

Python 提供了 2 种创建 set 集合的方法，分别是使用 {} 创建和使用 set() 函数将列表、元组等类型数据转换为集合。

1.使用 {} 创建

在 Python 中，创建 set 集合可以像列表、元素和字典一样，直接将集合赋值给变量，从而实现创建集合的目的，其语法格式如下：

setname = {element1,element2,…,elementn}

其中，setname 表示集合的名称，起名时既要符合 Python 命名规范，也要避免与 Python 内置函数重名。

2.set()函数创建集合

set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。该函数的语法格式如下：

setname = set(iteration)

如果要创建空集合，只能使用 set() 函数实现。因为直接使用一对 {}，Python 解释器会将其视为一个空字典。 ```python >>> set2 = set([1,2,3,4,5]) >>> set3 = set((1,2,3,4,5)) >>> print("set2:",set2) set2: {1, 2, 3, 4, 5} >>> print("set3:",set3) set3: {1, 2, 3, 4, 5} ``` ## 访问set集合元素 由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。 ## 删除set集合 手动函数集合类型，使用del()语句删除。 # Python set集合基本操作（添加、删除、交集、并集、差集） 常用的操作是向集合中添加、删除元素，以及集合之间做交集、并集、差集等运算。 ## 向set集合中添加元素 set集合添加元素，使用set类型提供的add()方法实现，语法格式： >setname.add(element) 其中，setname表示添加元素的集合，element表示要添加的元素内容。 使用 add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据，否则 Python 解释器会报 TypeError 错误。

set集合中删除元素

删除现有 set 集合中的指定元素，可以使用 remove() 方法，该方法的语法格式如下：

setname.remove(element)

set集合做交集、并集、差集运算

集合最常做的操作就是进行交集、并集、差集以及对称差集运算。

运算操作	Python运算符	含义	例子
交集	&	取两集合公共的元素	>>> set1 & set2
{3}
并集	\		取两集合全部的元素	>>> set1	set2
{1,2,3,4,5}
差集	-	取一个集合中另一集合没有的元素	>>> set1 - set2 {1,2} >>> set2 - set1	{4,5}
对称差集	^	取集合 A 和 B 中不属于 A&B 的元素	>>> set1 ^ set2 {1,2,4,5}