1.序列

序列是 Python 中最基本的一种数据结构（指计算机中数据存储的方式）

序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一位置（索引），并且序列中的数据会按照添加的顺序来分配索引

序列分为可变序列跟不可变序列

• 可变序列：元素可以改变

  • 列表（list）

• 不可变序列：元素不可以改变

  • 字符串（str）

  • 元组（tuple）

2. 列表（list）

列表是 Python中的一个对象。

列表可以保存多个有序的数据，顺序是按照插入的顺序存储。

列表中可以存储任意对象的数据。

• 列表的创建

  通过 []创建列表

  data_list = []
  print(data_list, type(data_list))
  ​
  >>>结果：
  [] <class 'list'>
  ​
  # 列表中可以存储多个元素
  data_list = [10, 12, 13, 14, 15, 16, 17, 18, 19, 20]
  print(data_list, type(data_list))
  ​
  >>>结果：
  [10, 12, 13, 14, 15, 16, 17, 18, 19, 20] <class 'list'>
  ​
  # 列表中的元素可以是任意元素
  data_list = ['itmahy', 2134, [1, 2, 3, 4, 5], 12.45]
  print(data_list, type(data_list))
  ​
  >>>结果：
  ['itmahy', 2134, [1, 2, 3, 4, 5], 12.45] <class 'list'>

3. 序列中的通用方法

实例以列表为例

• 可以通过索引（index - 索引是元素在列表中的位置，第一个位置的索引为 0）来获取列表中的元素，如果索引为负数，则 -1为倒数第一个。

  data_list = ['itmahy', 2134, [1, 2, 3, 4, 5], 12.45]
  # 获取索引为 0 的元素, 
  print(data_list[0])
  print(data_list[1])
  print(data_list[2])
  print(data_list[3])
  ​
  >>>结果：
  itmahy
  2134
  [1, 2, 3, 4, 5]
  12.45
  ​
  # 如果超出索引的范围，会抛出异常
  data_list = ['itmahy', 2134, [1, 2, 3, 4, 5], 12.45]
  print(data_list[4])
  ​
  >>>结果：
  Traceback (most recent call last):
    File "E:\XXXX.py", line 7, in <module>
      print(data_list[4])
  IndexError: list index out of range

• 获取列表中元素的个数

  len()函数，是列表的最大的索引 + 1

  data_list = ['itmahy', 2134, [1, 2, 3, 4, 5], 12.45]
  print(len(data_list))
  ​
  >>>结果：
  4

• 切片

  获取列表的一部分，相当于子列表，会产生一个新列表，对原列表不产生影响

  列表名称[索引起始位置 : 索引终止位置]，截取的元素包括起始，但是不包括终止，如果省略结束位置，则一直截取到最后，如果省略开始位置，则会从第一个位置开始截取，如果开始跟结束位置都省略，相当于复制了一个列表。

  data_list = ['itmahy', 2134, [1, 2, 3, 4, 5], 12.45]
  print(data_list[0 : 2 ])
  ​
  >>>结果：
  ['itmahy', 2134]

  列表名称[索引起始位置 : 索引终止位置 : 步长]

  步长表示每次获取元素的间隔，默认为 1。步长可以是负数，但是不能是 0。如果是负数，则是从后往前倒着取

  data_list = ['itmahy', 2134, [1, 2, 3, 4, 5], 12.45]
  print(data_list[0 : 3 : 2])
  ​
  >>>结果：
  ['itmahy', [1, 2, 3, 4, 5]]

• 通用操作

  • +和 *

    +可以将两个列表拼接为一个列表

    *跟字符串一个含义

    data_list = [1, 2, 3] + [4, 5, 6]
    print(data_list, type(data_list))
    print(data_list * 3)
    ​
    >>>结果：
    [1, 2, 3, 4, 5, 6] <class 'list'>
    [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

  • in和not in

    in：用来检查元素是否存在于列表中

    not in：与in相反

    data_list = [1, 2, 3] + [4, 5, 6]
    print(1 in data_list)
    print(2 not in  data_list)
    ​
    >>>结果：
    True
    False

  • min()和 min()

    min()获取列表中元素的最小值

    max()获取列表中元素的最大值

    data_list = [1, 2, 3] + [4, 5, 6]
    print(max(data_list))
    print(min(data_list))
    ​
    >>>结果：
    6
    1

  • 两个方法：

    index()获取指定元素在列表中的索引，如果元素不存在，则会抛出异常

    index(param1, param2, param3第一个参数是指查找的值，第二个参数表示查找的起始位置，第三个参数是指查找截至的位置

    data_list = [1, 2, 3] + [4, 5, 6]
    print(data_list.index(4))
    
    >>>结果：
    3
    
    data_list = [1, 2, 3] + [4, 5, 6]
    print(data_list.index(8))
    
    >>>结果：
    Traceback (most recent call last):
      File "XXX.py", line 16, in <module>
        print(data_list.index(8))
    ValueError: 8 is not in list

    count()统计元素在列表中出现的次数。

    data_list = [1, 2, 3] + [4, 5, 6, 3]
    print(data_list.count(3))
    
    >>>结果：
    2

• 列表的修改

  • 通过索引修改赋值或者删除

    data_list = ['a', 'b', 'c', 'd', 'e', 'f']
    print(data_list)
    
    data_list[5] = 'aa'
    print(data_list)
    
    # 删除元素
    del data_list[5]
    print(data_list)
    
    >>>结果：
    ['a', 'b', 'c', 'd', 'e', 'f']
    ['a', 'b', 'c', 'd', 'e', 'aa']
    ['a', 'b', 'c', 'd', 'e']

  • 通过切片修改和删除

    data_list = ['a', 'b', 'c', 'd', 'e', 'f']
    print(data_list)
    data_list[0 : 2] = 'ak'
    print(data_list)
    data_list[0 : 2] = '测试'
    print(data_list)
    data_list[0 : 2] = ['测试01', '测试02']
    print(data_list)
    data_list[0 : 0] = ['一个男人']
    print(data_list)
    del data_list[3 : ]
    print(data_list)
    
    >>> 结果：
    ['a', 'b', 'c', 'd', 'e', 'f']
    ['a', 'k', 'c', 'd', 'e', 'f']
    ['测', '试', 'c', 'd', 'e', 'f']
    ['测试01', '测试02', 'c', 'd', 'e', 'f']
    ['一个男人', '测试01', '测试02', 'c', 'd', 'e', 'f']
    ['一个男人', '测试01', '测试02']

  • 通过list()函数可以将不可变序列转为列表

4. 只对可变序列有用的方法

4.1 append(param)

列表中追加元素

data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)
data_list.append('1234')
print(data_list)

>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
['a', 'b', 'c', 'd', 'e', 'f', '1234']

4.2 insert(param1, param2)

向列表的指定位置插入一个元素

参数：

• 第一个参数：要插入的位置

• 第二个参数：要插入的元素

data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)
data_list.insert(2, '1234')
print(data_list)

>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
['a', 'b', '1234', 'c', 'd', 'e', 'f']

4.3 extend(param)

使用新序列来扩展原有序列，参数是一个序列。

data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
data_list.extend(my_list)
print(data_list)

>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
['a', 'b', 'c', 'd', 'e', 'f', 1, 2, 3, 4, 5, 6, 7, 8, 9]

4.4 clear()

清空列表的元素

data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)
data_list.clear()
print(data_list)

>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
[]

4.5 pop(param)

根据索引删除并返回指定元素，注意：如果不传参，则删除最后的一个元素

data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)
val = data_list.pop(2)
print(data_list)
print(val)

>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
['a', 'b', 'd', 'e', 'f']
c

4.6 remove(param)

删除指定值的元素，如果值有重复的，则删除第一个

data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)
data_list.remove('a')
print(data_list)

>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
['b', 'c', 'd', 'e', 'f']

4.7 reverse()

反转序列

data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)
data_list.reverse()
print(data_list)

>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
['f', 'e', 'd', 'c', 'b', 'a']

4.8 sort()

排序，默认是升序排列，当传参为sort(reverse = True)时，降序排列

data_list = list("asdfsdfhdvxcfgsrwerssdfsf")
print(data_list)
data_list.sort()
print(data_list)
data_list.sort(reverse=True)
print(data_list)

>>>结果：
['a', 's', 'd', 'f', 's', 'd', 'f', 'h', 'd', 'v', 'x', 'c', 'f', 'g', 's', 'r', 'w', 'e', 'r', 's', 's', 'd', 'f', 's', 'f']
['a', 'c', 'd', 'd', 'd', 'd', 'e', 'f', 'f', 'f', 'f', 'f', 'g', 'h', 'r', 'r', 's', 's', 's', 's', 's', 's', 'v', 'w', 'x']
['x', 'w', 'v', 's', 's', 's', 's', 's', 's', 'r', 'r', 'h', 'g', 'f', 'f', 'f', 'f', 'f', 'e', 'd', 'd', 'd', 'd', 'c', 'a']

4.8 遍历列表

data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)

i = 0

while i < len(data_list) :
    print(data_list[i])
    i += 1
    
>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
a
b
c
d
e
f

############################################
# for循环
data_list = ['a', 'b', 'c', 'd', 'e', 'f']
print(data_list)

for i in data_list :
    print(i)
    
>>>结果：
['a', 'b', 'c', 'd', 'e', 'f']
a
b
c
d
e
f

5. range()函数

用来生成一个自然数的序列

参数：

• 第一个参数：起始位置（可以省略，默认为 0）

• 第二个参数：截至位置

• 第三个参数：步长（可以省略，默认为 1）

a = range(5)
print(a)
print(list(a))

a = range(4, 10)
print(a)
print(list(a))

a = range(4, 10, 2)
print(a)
print(list(a))

>>>结果：
range(0, 5)
[0, 1, 2, 3, 4]
range(4, 10)
[4, 5, 6, 7, 8, 9]
range(4, 10, 2)
[4, 6, 8]

通过 range()可以创建一个指定次数的 for 循环

for i in range(4) :
    print(i)
    
>>>结果：
0
1
2
3

6. 元组（tuple）

元组是不可变序列，操作方式跟列表一致，操作元组时，就把元组当成是一个不可变的列表

一般当我们希望数据不会被改变时，就使用元组，其余情况都使用列表

语法：

[变量名] = () ： 表示创建了一个空元组

[变量名] = (1, 2, 3, 4, 5, 6)：表示创建一个元素个数为6的元组

当元组的元素不为空时，()可以省略，如果只有一个元素时，要在元素后面跟逗号

tuple_a = ()
print(tuple_a,type(tuple_a))
tuple_a = (1, 2, 3, 4, 5, 6)
print(tuple_a,type(tuple_a))
tuple_a = 1, 2, 3, 4, 5, 6
print(tuple_a,type(tuple_a))
tuple_a = 1
print(tuple_a,type(tuple_a))
tuple_a = (1)
print(tuple_a,type(tuple_a))
tuple_a = 1,
print(tuple_a,type(tuple_a))

>>>结果：
() <class 'tuple'>
(1, 2, 3, 4, 5, 6) <class 'tuple'>
(1, 2, 3, 4, 5, 6) <class 'tuple'>
1 <class 'int'>
1 <class 'int'>
(1,) <class 'tuple'>

元组的解包（解构）： 将元组中的每一个元素都赋值给一个变量，也可以交换两个变量的值

tuple_a = 1, 2, 3, 4
a, b, c, d = tuple_a

print(a)
print(b)
print(c)
print(d)

>>>结果：
1
2
3
4

a = 100 
b = 200
a, b = b, a
print(a)
print(b)

>>>结果：
200
100

在对一个元组进行解包时，变量的数量必须跟元组中的元素的数量保持一致。

也可以在变量前面加一个 *，这样变量就会获取元组中剩余的元素，*只能有一个

tuple_a = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
a, b, c, *d = tuple_a
print('a = ', a)
print('b = ', b)
print('c = ', c)
print('d = ', d)

print('='*20)

a, *b, c, d = tuple_a
print('a = ', a)
print('b = ', b)
print('c = ', c)
print('d = ', d)

>>>结果：
a =  1
b =  2
c =  3
d =  [4, 5, 6, 7, 8, 9, 10]
====================
a =  1
b =  [2, 3, 4, 5, 6, 7, 8]
c =  9
d =  10

注意：不光是元组可以解包，列表跟字符串也可以解包

7. 可变对象

• 每个对象中都保存了 id type value三个属性，可变对象指的是value可变

• 列表就是一个可变对象，如果是通过变量修改对象中某个元素的值，就是改对象，那么就没有产生新的对象，只是修改了原来的对象，如果给变量重新赋值，则是改变量，是将一个新的对象赋值给变量。

• 当修改对象时，如果其他变量也指向了该对象，那么修改的值也会在其他变量中体现

• == != 与 is is not的区别：

  • == != ： 比较的是对象的值是否相等

  • is is not：比较的是对象的 id 是否相等

8. 字典（dict）

• 字典属于一种新的数据结构，称为映射(mapping)，不属于序列

• 字典的作用个列表一样，都是用来存储对象的容器

• 列表存储数据性能很好，但是查询性能很差

• 字典中每一个元素都有一个唯一的名字，通过唯一的名字可以查询指定的元素

• 字典中可以保存多个对象，每个对象都有一个唯一的名字（键-key），对象称之为值（value），所以字典称之为键值对

8.1 创建字典

[变量名] = {}

[变量名] = {key : value, key1 : value, ...}

字典的键不可重复，如果重复后边的会替换前面的。数据类型只能是不可变对象

[变量名] = dict(key = value, key1 = value, ...)，这种方式创建的字段，key 都是字符串

也可以将含有双值子序列（序列中只有两个值）的序列转换为字典。

dict_a =  {'name' : 'itmahy', 'age' : 18, 'gender' : '男'}
print(dict_a, type(dict_a), id(dict_a))

>>>结果：
{'name': 'itmahy', 'age': 18, 'gender': '男'} <class 'dict'> 2670881344768

=================================================================================

dict_b = dict(name = 'itmahy', age = 18, gender = '男')
print(dict_b, type(dict_b), id(dict_b))

>>>结果：
{'name': 'itmahy', 'age': 18, 'gender': '男'} <class 'dict'> 225550709670

=================================================================================

list_a = [('name','itmahy'),('age',18),('gender', '男')]
dict_c = dict(list_a)
print(dict_c, type(dict_c), id(dict_c))

>>>结果：
{'name': 'itmahy', 'age': 18, 'gender': '男'} <class 'dict'> 1498795345152

8.2 获取值

变量名[key]，如果 key不存在，则会抛出异常

dict_a =  {'name' : 'itmahy', 'age' : '18', 'gender' : '男'}
print(dict_a, type(dict_a), id(dict_a))

print(dict_a['name'])
print(dict_a['address'])

>>>结果：
{'name': 'itmahy', 'age': '18', 'gender': '男'} <class 'dict'> 2081242680576
itmahy
Traceback (most recent call last):
  File "XXX.py", line 171, in <module>
    print(dict_a['address'])
KeyError: 'address'

8.3 字典的使用

• len()获取键值对的个数

• in检查字典中是否包含指定的键

• not in检查字典中是否不包含指定的键

  list_a = [('name','itmahy'),('age',18),('gender', '男')]
  dict_c = dict(list_a)
  
  print(len(dict_c))
  print('name' in dict_c)
  print('age' not in dict_c)
  
  >>>结果：
  3
  True
  False

• get(key)根据 key 获取值，如果 key不存在，则返回 None

  list_a = [('name','itmahy'),('age',18),('gender', '男')]
  dict_c = dict(list_a)
  
  print(dict_c.get('name'))
  print(dict_c.get('address'))
  
  >>>结果：
  itmahy
  None

• 修改字典中元素的值

  • 变量名[key] = 新值，如果 key 不存在，则会添加

    list_a = [('name','itmahy'),('age',18),('gender', '男')]
    dict_c = dict(list_a)
    
    dict_c['name'] = '一个男人'
    dict_c['address'] = '宁夏'
    print(dict_c, type(dict_c), id(dict_c))
    
    >>>结果：
    {'name': '一个男人', 'age': 18, 'gender': '男', 'address': '宁夏'} <class 'dict'> 1730596962944

  • setdefault(key,value)如果 key 存在，则返回 key 的值，不会修改字典，如果 key 不存在，则向字典中添加这个 key，并设置value

    list_a = [('name','itmahy'),('age',18),('gender', '男')]
    dict_c = dict(list_a)
    
    result = dict_c.setdefault('name','嘿嘿')
    result1 = dict_c.setdefault('address','一个地址')
    
    print(dict_c, type(dict_c), id(dict_c))
    print('result = ',result )
    print('result1 = ',result1 )
    
    >>>结果：
    {'name': 'itmahy', 'age': 18, 'gender': '男', 'address': '一个地址'} <class 'dict'> 1367825959488
    result =  itmahy # name 这个 key 存在，返回原有key 的值
    result1 =  一个地址 # address不存在，则添加

• update()将其他字典中的元素添加到当前字典中，如果 key 重复，后面的元素还是会替换前面的元素

  list_a = [('name','itmahy'),('age',18),('gender', '男')]
  dict_c = dict(list_a)
  
  dict_d = {'a':'1','b': '2','name' : '测试'}
  
  dict_c.update(dict_d)
  
  print(dict_c, type(dict_c), id(dict_c))
  
  >>>结果：
  {'name': '测试', 'age': 18, 'gender': '男', 'a': '1', 'b': '2'} <class 'dict'> 2436495492864

• 删除字典中的元素

  • del 变量名[key]删除指定 key 的元素，如果 key 不存在，则会抛出异常，

  • popitem() 随机删除元素，一般都是删除最后的一个元素，有返回值，返回的是被删除的元素（一个有两个值的元组），如果是空字典，则会抛出异常。

  • pop(key)删除指定 key 的元素，返回值是 删除元素的 value。如果 key 不存在，则会抛出异常，如果指定默认值（pop(key,default)），则返回默认值。

  • clear()清空字典

    ===================根据 dict[key] 删除=============================
    # key存在，则删除
    dict_d = {'a':'1','b': '2','name' : '测试'}
    del dict_d['a']
    
    print(dict_d)
    
    >>>结果：
    {'b': '2', 'name': '测试'}
    
    # key不存在，抛出异常
    dict_d = {'a':'1','b': '2','name' : '测试'}
    del dict_d['z']
    
    print(dict_d)
    
    >>>结果：
    Traceback (most recent call last):
      File "XXX.py", line 206, in <module>
        del dict_d['z']
    KeyError: 'z'
    
    =====================根据 popitem()删除=========================
    # key存在，则删除
    dict_d = {'a':'1','b': '2','name' : '测试'}
    result = dict_d.popitem()
    
    print(dict_d)
    print(result)
    
    >>>结果：
    {'a': '1', 'b': '2'}
    ('name', '测试')
    
    # 字典为空，抛出异常
    dict_e = {}
    dict_e.popitem()
    
    >>>结果：
    Traceback (most recent call last):
      File "XXX.py", line 213, in <module>
        dict_e.popitem()
    KeyError: 'popitem(): dictionary is empty'
    
    =====================根据 pop()删除=========================
    # key存在，则删除，返回被删除元素的 value
    dict_d = {'a':'1','b': '2','name' : '测试'}
    result = dict_d.pop('a')
    
    print(dict_d)
    print(result)
    
    >>>结果：
    {'b': '2', 'name': '测试'}
    1
    
    # key不存在，抛出异常
    
    dict_d = {'a':'1','b': '2','name' : '测试'}
    result = dict_d.pop('z')
    
    print(dict_d)
    print(result)
    
    >>>结果：
    Traceback (most recent call last):
      File "XXX.py", line 206, in <module>
        result = dict_d.pop('z')
    KeyError: 'z'
    
    # key不存在，设置默认值，则返回默认值
    dict_d = {'a':'1','b': '2','name' : '测试'}
    result = dict_d.pop('z','这是默认值')
    
    print(dict_d)
    print(result)
    
    >>>结果：
    {'a': '1', 'b': '2', 'name': '测试'}
    这是默认值

• copy()对字典进行浅复制。

  类似于以下代码，不是复制，只是两个变量指向了同一个对象（id一样），如果修改 dict_d，那么dict_f也会修改

  dict_d = {'a':'1','b': '2','name' : '测试'}
  dict_f = dict_d
  
  print(dict_d, id(dict_d))
  print(dict_f, id(dict_f))
  
  >>>结果：
  {'a': '1', 'b': '2', 'name': '测试'} 1736099302656
  {'a': '1', 'b': '2', 'name': '测试'} 1736099302656

  如果使用了复制，则会产生一个新对象，两个是独立的，修改一个不会修改另外一个对象

  dict_d = {'a':'1','b': '2','name' : '测试'}
  dict_f = dict_d.copy()
  
  print(dict_d, id(dict_d))
  print(dict_f, id(dict_f))
  
  >>>结果：
  {'a': '1', 'b': '2', 'name': '测试'} 1294305135872 # 对象的 id不一样
  {'a': '1', 'b': '2', 'name': '测试'} 1294305136128

  浅复制：只会复制字典本身，如果字典中还有字典（或者可变对象），那么这个可变对象不会被复制，如果修改的话，还是会影响原对象的值

  dict_d = {'a':'1','b': '2','name' : '测试','c':{'we':'dfd','name': 'itmahy'}}
  dict_f = dict_d.copy()
  
  print(dict_d, id(dict_d))
  print(dict_f, id(dict_f))
  
  dict_f['c']['name'] = '一个男人'
  
  print(dict_d, id(dict_d))
  print(dict_f, id(dict_f))
  
  >>>结果：
  {'a': '1', 'b': '2', 'name': '测试', 'c': {'we': 'dfd', 'name': 'itmahy'}} 2564038790656
  {'a': '1', 'b': '2', 'name': '测试', 'c': {'we': 'dfd', 'name': 'itmahy'}} 2564038790464
  # 下面就是修改了 dict_f 中 c 这个字典中的name，那么 dict_d 中 c 这个字典中的name 也发生了改变，这就是浅复制
  {'a': '1', 'b': '2', 'name': '测试', 'c': {'we': 'dfd', 'name': '一个男人'}} 2564038790656
  {'a': '1', 'b': '2', 'name': '测试', 'c': {'we': 'dfd', 'name': '一个男人'}} 2564038790464

8.4 遍历字典

keys()：返回字典中所有的 key，返回一个序列，序列中包含所有的 key

dict_d = {'a':'1','b': '2','name' : '测试','c':{'we':'dfd','name': 'itmahy'}}

result = dict_d.keys()

print(result)

for key in result :
    print(dict_d[key])
>>>结果：
dict_keys(['a', 'b', 'name', 'c'])
1
2
测试
{'we': 'dfd', 'name': 'itmahy'}

values()：返回字典中所有的值，返回一个序列，序列中包含所有的值

dict_d = {'a':'1','b': '2','name' : '测试','c':{'we':'dfd','name': 'itmahy'}}

result = dict_d.values()

print(result)

for value in result :
    print(value)

>>>结果：
dict_values(['1', '2', '测试', {'we': 'dfd', 'name': 'itmahy'}])
1
2
测试
{'we': 'dfd', 'name': 'itmahy'}

items()：返回字典中所有的元素，返回一个序列，序列中包含双值子序列

dict_d = {'a':'1','b': '2','name' : '测试','c':{'we':'dfd','name': 'itmahy'}}

result = dict_d.items()

print(result)

for k,v in result :
    print(k, '=', v)
    
>>>结果：
dict_items([('a', '1'), ('b', '2'), ('name', '测试'), ('c', {'we': 'dfd', 'name': 'itmahy'})])
a = 1
b = 2
name = 测试
c = {'we': 'dfd', 'name': 'itmahy'}

9. 集合（set）

集合和列表非常相似，不同的是，集合只存储不可变对象，集合中存储的对象是无序的（不是按照元素的插入的顺序排序的），集合中不能出现重复的元素，没有元素都是唯一的。集合是没有办法使用索引取值的。通用的方法在集合中也是能用的。

9.1 创建集合

• {}创建，如果有重复元素则被清除掉，如果创建空集合，不能使用{}这时表示它是一个字典，要创建空集合，只能使用set()

  set_a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}
  print(set_a, type(set_a))
  
  >>>结果：
  {1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>

• set()创建

  # set()将序列（list, str, tuple...）转为集合
  set_a = set([1,2,3,4,5])
  print(set_a, type(set_a))
  
  >>>结果：
  {1, 2, 3, 4, 5} <class 'set'>
  
  # 创建空集合
  set_a = set()
  print(set_a, type(set_a))
  
  >>>结果：
  set() <class 'set'>
  
  # 将字符串转为集合
  set_a = set('hello world')
  print(set_a, type(set_a))
  
  >>>结果：
  {'h', 'o', 'e', 'w', 'r', 'l', ' ', 'd'} <class 'set'>
  
  # 将字典转为集合，集合中只有字典的key
  set_a = set({'a':'1','b': '2','name' : '测试','c':{'we':'dfd','name': 'itmahy'}})
  print(set_a, type(set_a))
  
  >>>结果：
  {'b', 'c', 'name', 'a'} <class 'set'>
  
  # 将元组转为集合，必须有(),不然报错
  set_a = set((1,2,3,4))
  print(set_a, type(set_a))
  
  >>>结果：
  {1, 2, 3, 4} <class 'set'>

9.2 方法

• 序列中的方法集合是通用的

• add()向集合中添加元素

  # 添加元素
  set_a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}
  set_a.add('a')
  
  print(set_a, type(set_a))
  
  >>>结果：
  {1, 2, 3, 4, 5, 6, 7, 8, 9, 'a'} <class 'set'>

• update(T)将一个序列中的元素添加到集合中，当参数为字典时，添加的只是字典的 key

  # 字符串
  set_a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}
  set_a.update('hello')
  print(set_a, type(set_a))
  
  >>>结果：
  {1, 2, 3, 4, 5, 6, 7, 8, 9, 'l', 'o', 'e', 'h'} <class 'set'>
  
  # 集合
  set_a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}
  set_a.update({'a','b','c','d','e','f','g','h','i','j'})
  print(set_a, type(set_a))
  
  >>>结果：
  {'d', 1, 2, 3, 4, 5, 6, 7, 8, 9, 'h', 'j', 'e', 'g', 'c', 'f', 'b', 'a', 'i'} <class 'set'>
  
  # 字典
  set_a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}
  set_a.update({'a':'ab','b':'ba'})
  print(set_a, type(set_a))
  
  >>>结果：
  {1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b'} <class 'set'>
  
  # 元组
  set_a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}
  set_a.update(('a','b','c'))
  print(set_a, type(set_a))
  
  >>>结果：
  {'a', 1, 2, 3, 4, 5, 6, 7, 8, 9, 'c', 'b'} <class 'set'>

• pop()随机删除一个集合中的元素，返回被删除的元素

  set_a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}
  set_a.update(('a','b','c'))
  
  result = set_a.pop()
  
  print(set_a, type(set_a))
  print(result)
  
  >>>结果：
  {2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c'} <class 'set'>
  1

• remove(param)：删除集合中指定的元素，没有返回值

  set_a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}
  set_a.update(('a','b','c'))
  
  result = set_a.remove('a')
  
  print(set_a, type(set_a))
  print(result)
  
  >>>结果：
  {1, 2, 3, 4, 5, 6, 7, 8, 9, 'c', 'b'} <class 'set'>
  None

• clear()：清空集合

• copy()：浅复制集合

9.3 集合的运算

&交集

set_a = {1,2,3,4,5}
set_b = {3,4,5,6,7}
result = set_a & set_b
print(result)

>>>结果：
{3, 4, 5}

|并集

set_a = {1,2,3,4,5}
set_b = {3,4,5,6,7}
result = set_a | set_b
print(result)

>>>结果：
{1, 2, 3, 4, 5, 6, 7}

-差集

set_a = {1,2,3,4,5}
set_b = {3,4,5,6,7}
result = set_a - set_b
print(result)

>>>结果：
{1, 2}

^亦或集，获取只在一个集合中出现的元素

set_a = {1,2,3,4,5}
set_b = {3,4,5,6,7}
result = set_a ^ set_b
print(result)

>>>结果：
{1, 2, 6, 7}

<=检查一个集合是否是另外一个集合的子集

# set_a 不是 set_b 的子集  set_b 不是 set_a 的超集
set_a = {1,2,3,4,5}
set_b = {3,4,5,6,7}
result = set_a <= set_b
print(result)

>>>结果：
False

# set_a 是 set_b 的子集  set_b 是 set_a 的超集
set_a = {3,4,5}
set_b = {3,4,5,6,7}
result = set_a <= set_b
print(result)

>>>结果：
True

<检查一个集合是否是另外一个集合的真子集

# set_a 不是 set_b 的真子集  
set_a = {3,4,5}
set_b = {3,4,5}
result = set_a < set_b
print(result)

>>>结果：
False

# set_a 是 set_b 的真子集  
set_a = {3,4,5}
set_b = {3,4,5,6}
result = set_a < set_b
print(result)

>>>结果：
True

>=检查一个集合是否是另一个集合的超集

>检查一个集合是否是另一个集合的真超集