python学习笔记：数据类型

      python是一门热门的编程语言，也是一门热门的脚本语言，python中的六大标准类型分别为：数字、字符串、列表、元组、集合、字典。

首先来看一下 Python 标准数据类型的分类：

类型	例子	类型	例子
List(列表)	[1, 1.2, 'hello']	长整型	1000000000000L
Set(集合)	{1, 2, 3}	bool(布尔型)	True, False
Dictionary(字典)	{'dogs': 5, 'pigs': 3}	float(浮点数)	3.1416
String(字符串)	'hello'	Numpy数组	array([1, 2, 3])
Tuple(元组)	('ring', 1000)	Pandas类型	DataFrame
Number(数字)int(整数)	-100	Series自定义	Object Oriented Classes

 

 

 

 

 

 

 

 

一、数字（Number)

在Python中运算是有优先级的，优先级即算术的先后顺序，比如“先乘除后加减”和“先算括号里面的”都是两种优先级的规则，优先级从高到低排列如下：

• ( ) 括号
• ** 幂指数运算
• * / // % 乘，除，整数除法，取余运算
• '+ -' 加减

1、整数(int)

整型数字的最大最小值：

• 在 32 位系统中，一个整型 4 个字节，最小值 -2,147,483,648，最大值 2,147,483,647。
• 在 64 位系统中，一个整型 8 个字节，最小值 -9,223,372,036,854,775,808，最大值 9,223,372,036,854,775,807。

#整型运算，加减乘除：
print(2+2)  #4
print(3-4)  #-1
print(4*5)  #20
print(12/5) #2.4
#幂指数
print(2**5) #32
#取余
print(32%5) #2
#赋值给变量
a=1
print(a)    #1
print(type(a))  #<class 'int'>

2、浮点数 Float

#浮点型运算，加减乘除
print(5+2.4) #7.4
print(3.4-3.2) #0.19999999999999973   注意看 3.4 - 3.2 的结果并不是我们预期的0.2，这是因为浮点数本身储存方式引起的，浮点数本身会存在一点误差。
print(3.4*3.2) #10.88
print(12.0/5)  #2.4
#幂指数
print(2.5**2) #6.25
#取余
print(3.4%2.1) #1.2999999999999998
#类型转换
print (int(12.324))#12
print (int(-3.52))#-3

3、其他进制

#科学计数法：
print(1e-6)  #1e-06
#16进制，前面加0x修饰，后面使用数字0-9A-F：
print(0xFF)  #255
#8进制，前面加0o修饰，后面使用数字0-7：
print(0o67)  #55
#2进制，前面加0b修饰，后面使用数字0或1：
print(0b101010)  #42

二、字符串

1、生成字符串

Python中可以使用一对单引号''或者双引号""生成字符串。

s = "hello, world"
print (s)  #hello, world
#+加法
s = 'hello ' + 'world'
print(s)  #hello world
#字符串与数字相乘
print("echo" * 3) #echoechoecho
#字符串长度：
print(len(s))  #11

2、字符串方法

      Python是一种面向对象的语言，面向对象的语言中一个必不可少的元素就是方法，而字符串是对象的一种，所以有很多可用的方法。跟很多语言一样，Python使用以下形式来调用方法：

对象.方法(参数)

'1、分割s.split()'
#将s按照空格（包括多个空格，制表符\t，换行符\n等）分割，并返回所有分割得到的字符串。
line = "1 2 3 4  5"
numbers = line.split()
print(numbers) #['1', '2', '3', '4', '5']
'2、连接s.join(str_sequence)'
#与分割相反，s.join(str_sequence)的作用是以s为连接符将字符串序列str_sequence中的元素连接起来，并返回连接后得到的新字符串：
s = ' '
print(s.join(numbers)) #1 2 3 4 5
'3、替换s.replace(part1, part2)'
#将字符串s中指定的部分part1替换成想要的部分part2，并返回新的字符串。
s = "hello world"
print(s.replace('world', 'python')) #hello python
#此时，s的值并没有变化，替换方法只是生成了一个新的字符串。
print(s)  #hello world
'4、大小写转换'
#s.upper()方法返回一个将s中的字母全部大写的新字符串。
#s.lower()方法返回一个将s中的字母全部小写的新字符串。
print("hello world".upper())#'HELLO WORLD'
#这两种方法也不会改变原来s的值：
s = "HELLO WORLD"
print(s.lower())  #hello world
print(s)  #HELLO WORLD
'5、去除多余空格'
#s.strip()返回一个将s两端的多余空格除去的新字符串。
#s.lstrip()返回一个将s开头的多余空格除去的新字符串。
#s.rstrip()返回一个将s结尾的多余空格除去的新字符串。
s = "  hello world   "
print(s.strip()) #'hello world'
#s的值依然不会变化：
print(s) #'  hello world   '
print(s.lstrip()) #'hello world   '
print(s.rstrip()) #'  hello world'
'6、更多方法'
#可以使用dir函数查看所有可以使用的方法：
print(dir(s))
#['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

3、整数与不同进制的字符串的转化

可以将整数按照不同进制转化为不同类型的字符串。

'十六进制hex()'
print(hex(255))  #'0xff'
'八进制oct()'
print(oct(255))  #'0377'
'二进制bin()'
print(bin(255))  #'0b11111111'
#可以使用 int 将字符串转为整数：
print(int('23'))  #23
#还可以指定按照多少进制来进行转换，最后返回十进制表达的整数
print(int('FF', 16)) #255
print(int('377', 8)) #255
print(int('11111111', 2)) #255
#float 可以将字符串转换为浮点数
print(float('3.5')) #3.5

4、格式化字符串

Python用字符串的format()方法来格式化字符串。

#字符串中花括号 {} 的部分会被format传入的参数替代，传入的值可以是字符串，也可以是数字或者别的对象。
print('{} {} {}'.format('a', 'b', 'c')) #'a b c'
#可以用数字指定传入参数的相对位置：
print('{2} {1} {0}'.format('a', 'b', 'c')) #'c b a'
#还可以指定传入参数的名称:
print('{color} {n} {x}'.format(n=10, x=1.5, color='blue')) #'blue 10 1.5'
#可以在一起混用：
print('{color} {0} {x} {1}'.format(10, 'foo', x = 1.5, color='blue'))  #'blue 10 1.5 foo'
#可以用{<field name>:<format>}指定格式：
from math import pi
print('{0:10} {1:10d} {2:10.2f}'.format('foo', 5, 2 * pi)) #'foo                 5       6.28'
#具体规则与C中相同。
#也可以使用旧式的 % 方法进行格式化：
s = "some numbers:"
x = 1.34
y = 2
# 用百分号隔开，括号括起来
t = "%s %f, %d" % (s, x, y)
print(t) # 'some numbers: 1.340000, 2'

5、索引和分片

'1、索引'
#对于一个有序序列，可以通过索引的方法来访问对应位置的值。字符串便是一个有序序列的例子，Python使用 [] 来对有序序列进行索引。
s = "hello world"
print(s[0])  #'h'
#Python中索引是从 0 开始的，所以索引 0 对应与序列的第 1 个元素。为了得到第 5 个元素，需要使用索引值 4 。
print(s[4])  #'o'
#除了正向索引，Python还引入了负索引值的用法，即从后向前开始计数，例如，索引 -2 表示倒数第 2 个元素：
print(s[-2]) #'l'
#单个索引大于等于字符串的长度时，会报错：
#print(s[11])  #IndexError: string index out of range
'2、分片'
#分片用来从序列中提取出想要的子序列，其用法为：
 #'''var[lower:upper:step]'''
#其范围包括 lower ，但不包括 upper ，即 [lower, upper)， step 表示取值间隔大小，如果没有默认为1。
print(s)  #'hello world'
print(s[1:3])  #'el' #分片中包含的元素的个数为 3-1=2 。
#也可以使用负索引来指定分片的范围：
print(s[1:-2])  #'ello wor' #包括索引 1 但是不包括索引 -2 。

#lower和upper可以省略，省略lower意味着从开头开始分片，省略upper意味着一直分片到结尾。
print(s[:3])   #'hel'
print(s[-3:])  #'rld'
print(s[:]) #'hello world'

#每隔两个取一个值：
print(s[::2])  #'hlowrd'

#当step的值为负时，省略lower意味着从结尾开始分片，省略upper意味着一直分片到开头。
print(s[::-1])   #'dlrow olleh'
#当给定的upper超出字符串的长度（注意：因为不包含upper，所以可以等于）时，Python并不会报错，不过只会计算到结尾。
print(s[:100])  #'hello world'

三、列表list

1、生成列表

在Python中，列表是一个有序的序列。

列表用一对 [] 生成，中间的元素用 , 隔开，其中的元素不需要是同一类型，同时列表的长度也不固定。

l = [1, 2.0, 'hello']
print(l)  #[1, 2.0, 'hello']
#空列表可以用 [] 或者 list() 生成：
empty_list = []
print(empty_list) #[]
empty_list = list()
print(empty_list) #[]

2、列表操作

与字符串类似，列表也支持以下的操作：

'1、长度'
#用 len 查看列表长度：
print(len(l))  #3

'2、加法和乘法'
#列表加法，相当于将两个列表按顺序连接：
a = [1, 2, 3]
b = [3.2, 'hello']
print(a + b)  #[1, 2, 3, 3.2, 'hello']
#列表与整数相乘，相当于将列表重复相加：
print(l * 2)  #[1, 2.0, 'hello', 1, 2.0, 'hello']

'3、索引和分片'
#列表和字符串一样可以通过索引和分片来查看它的元素。
#索引：
a = [10, 11, 12, 13, 14]
print(a[0])  #10
#分片：
print(a[2:-1]) #[12, 13]
#与字符串不同的是，列表可以通过索引和分片来修改。
a = [10, 11, 12, 13, 14]
a[0] = 100
print(a)  #[100, 11, 12, 13, 14]
#这种赋值也适用于分片，例如，将列表的第2，3两个元素换掉：
a[1:3] = [1, 2]
print(a) #[100, 1, 2, 13, 14]
#事实上，对于连续的分片（即步长为 1 ），Python采用的是整段替换的方法，两者的元素个数并不需要相同，例如，将 [11,12] 替换为 [1,2,3,4]：
a = [10, 11, 12, 13, 14]
a[1:3] = [1, 2, 3, 4]
print(a) #[10, 1, 2, 3, 4, 13, 14]
#这意味着，可以用这种方法来删除列表中一个连续的分片：
a = [10, 1, 2, 11, 12]
print(a[1:3]) #[1, 2]
a[1:3] = []
print(a) #[10, 11, 12]
#对于不连续（间隔step不为1）的片段进行修改时，两者的元素数目必须一致：
a = [10, 11, 12, 13, 14]
a[::2] = [1, 2, 3]
print(a)  #[1, 11, 2, 13, 3]
#否则会报错：
#a[::2] = [] #ValueError: attempt to assign sequence of size 0 to extended slice of size 3

'4、删除元素del'
#Python提供了删除列表中元素的方法 'del'。
#删除列表中的第一个元素：
a = [1002, 'a', 'b', 'c']
del a[0]
print(a) #['a', 'b', 'c']
#删除第2到最后一个元素：
a = [1002, 'a', 'b', 'c']
del a[1:]
print(a) #[1002]
#删除间隔的元素：
a = ['a', 1, 'b', 2, 'c']
del a[::2]
print(a)  #[1, 2]

'5、测试从属关系'
#用 in 来看某个元素是否在某个序列（不仅仅是列表）中，用not in来判断是否不在某个序列中。
a = [10, 11, 12, 13, 14]
print(10 in a) #True
print(10 not in a) #False
#也可以作用于字符串：
s = 'hello world'
print('he' in s) #True
print('world' not in s) #False
#列表中可以包含各种对象，甚至可以包含列表：
a = [10, 'eleven', [12, 13]]
print(a[2]) #[12, 13]
#a[2]是列表，可以对它再进行索引：
print(a[2][1]) #13

3、列表方法

'不改变列表的方法'
'1、列表中某个元素个数count'
#l.count(ob) 返回列表中元素 ob 出现的次数。
a = [11, 12, 13, 12, 11]
print(a.count(11)) #2
'2、列表中某个元素位置index'
#l.index(ob) 返回列表中元素 ob 第一次出现的索引位置，如果 ob 不在 l 中会报错。
a.index(12)  #1
#不存在的元素会报错：
#print(a.index(1)) #ValueError: 1 is not in list

'改变列表的方法'
'3、向列表添加单个元素append'
#l.append(ob) 将元素 ob 添加到列表 l 的最后。
a = [10, 11, 12]
a.append(11)
print(a) #[10, 11, 12, 11]
#append每次只添加一个元素，并不会因为这个元素是序列而将其展开：
a.append([11, 12])
print(a) #[10, 11, 12, 11, [11, 12]]
'4、向列表添加序列extend'
#l.extend(lst) 将序列 lst 的元素依次添加到列表 l 的最后，作用相当于 l += lst。
a = [10, 11, 12, 11]
a.extend([1, 2])
print(a) #[10, 11, 12, 11, 1, 2]
'5、插入元素insert'
#l.insert(idx, ob) 在索引 idx 处插入 ob ，之后的元素依次后移。
a = [10, 11, 12, 13, 11]
# 在索引 3 插入 'a'
a.insert(3, 'a')
print(a) #[10, 11, 12, 'a', 13, 11]
'6、移除元素remove'
#l.remove(ob) 会将列表中第一个出现的 ob 删除，如果 ob 不在 l 中会报错。
a = [10, 11, 12, 13, 11]
# 移除了第一个 11
a.remove(11)
print(a) #[10, 12, 13, 11]
'7、弹出元素pop'
#l.pop(idx) 会将索引 idx 处的元素删除，并返回这个元素。
a = [10, 11, 12, 13, 11]
print(a.pop(2)) #12
'8、排序sort'
#l.sort() 会将列表中的元素按照一定的规则排序：
a = [10, 1, 11, 13, 11, 2]
a.sort()
print(a)  #[1, 2, 10, 11, 11, 13]
#如果不想改变原来列表中的值，可以使用 sorted 函数：
a = [10, 1, 11, 13, 11, 2]
b = sorted(a)
print(a)  #[10, 1, 11, 13, 11, 2]
print(b)  #[1, 2, 10, 11, 11, 13]
'9、列表反向reverse'
#l.reverse() 会将列表中的元素从后向前排列。
a = [1, 2, 3, 4, 5, 6]
a.reverse()
print(a) #[6, 5, 4, 3, 2, 1]
#如果不想改变原来列表中的值，可以使用这样的方法：
a = [1, 2, 3, 4, 5, 6]
b = a[::-1]
print(a)  #[1, 2, 3, 4, 5, 6]
print(b)  #[6, 5, 4, 3, 2, 1]

四、元组（tuple)

1、生成元组(tuple)

与列表相似，元组Tuple也是个有序序列，但是元组是不可变的，用()生成。

t = (10, 11, 12, 13, 14)
print(t)  #(10, 11, 12, 13, 14)
print(type(t)) #<class 'tuple'>

2、基本操作

'1、可以索引，切片：'
print(t[0])  #10
print(t[1:3]) #(11, 12)
#但是元组是不可变的：
#t[0] = 1  #TypeError: 'tuple' object does not support item assignment

'2、单个元素的元组生成'
#由于()在表达式中被应用，只含有单个元素的元组容易和表达式混淆，所以采用下列方式定义只有一个元素的元组：
a = (10,)
print(a)  #(10,)
print(type(a))  #<class 'tuple'>
a = (10)
print(type(a))  #<class 'int'>
#将列表转换为元组：
a = [10, 11, 12, 13, 14]
print(tuple(a))  #(10, 11, 12, 13, 14)
'3、元组方法'
#由于元组是不可变的，所以只能有一些不可变的方法，例如计算元素个数 count 和元素位置 index ，用法与列表一样。
#计算元素个数 count
print(a.count(10))  #1
#元素位置 index
print(a.index(12))  #2

为什么需要元组

旧式字符串格式化中参数要用元组；在字典中当作键值；数据库的返回值……

五、字典

字典 dictionary ，在一些编程语言中也称为 hash ， map ，是一种由键值对组成的数据结构。

顾名思义，我们把键想象成字典中的单词，值想象成词对应的定义，那么一个词可以对应一个或者多个定义，但是这些定义只能通过这个词来进行查询。

1、生成字典(dict)

Python 使用 {} 或者 dict() 来创建一个空的字典：

a = {}
print(type(a)) #<class 'dict'>
a = dict()
print(type(a)) #<class 'dict'>

2、字典操作

有了dict之后，可以用索引键值的方法向其中添加元素，也可以通过索引来查看元素的值：

'1、插入键值'
a["one"] = "this is number 1"
a["two"] = "this is number 2"
print(a)  #{'one': 'this is number 1', 'two': 'this is number 2'}
'2、查看键值'
print(a['one']) #'this is number 1'
'3、更新键值'
a["one"] = "this is number 1, too"
print(a)  #{'one': 'this is number 1, too', 'two': 'this is number 2'}
'4、初始化字典'
#可以看到，Python使用key: value这样的结构来表示字典中的元素结构，事实上，可以直接使用这样的结构来初始化一个字典：
b = {'one': 'this is number 1', 'two': 'this is number 2'}
print(b['one']) #'this is number 1'
'5、字典没有顺序'
#当我们 print 一个字典时，Python并不一定按照插入键值的先后顺序进行显示,因为字典中的键本身不一定是有序的。
print(a) #{'two': 'this is number 2', 'one': 'this is number 1, too'}
print(b) #{'two': 'this is number 2', 'one': 'this is number 1'}
#因此，Python中不能用支持用数字索引按顺序查看字典中的值，而且数字本身也有可能成为键值，这样会引起混淆：
#print(a[0]) #KeyError: 0
'6、使用 dict 初始化字典'
#除了通常的定义方式，还可以通过 dict() 转化来生成字典：
inventory = dict(
    [('foozelator', 123),
     ('frombicator', 18), 
     ('spatzleblock', 34), 
     ('snitzelhogen', 23)
    ])
print(inventory) #{'foozelator': 123, 'frombicator': 18, 'snitzelhogen': 23, 'spatzleblock': 34}
#利用索引直接更新键值对：
inventory['frombicator'] += 1
print(inventory) #{'foozelator': 123, 'frombicator': 19, 'snitzelhogen': 23, 'spatzleblock': 34}
'7、适合做键的类型：整数、字符串、元组'
#在不可变类型中，整数和字符串是字典中最常用的类型；而浮点数通常不推荐用来做键，原因如下：
data = {}
data[1.1 + 2.2] = 6.6
# 会报错
#data[3.3] #KeyError: 3.3 #事实上，观察data的值就会发现，这个错误是由浮点数的精度问题所引起的

#有时候，也可以使用元组作为键值，例如，可以用元组做键来表示从第一个城市飞往第二个城市航班数的多少：
connections = {}
connections[('New York', 'Seattle')] = 100
connections[('Austin', 'New York')] = 200
connections[('New York', 'Austin')] = 400
#元组是有序的，因此 ('New York', 'Austin') 和 ('Austin', 'New York') 是两个不同的键：
print(connections[('Austin', 'New York')]) #200
print(connections[('New York', 'Austin')]) #400

3、字典方法

'1、get 方法'
#之前已经见过，用索引可以找到一个键对应的值，但是当字典中没有这个键的时候，Python会报错，这时候可以使用字典的 get 方法来处理这种情况，其用法如下：
'd.get(key, default = None)'
#返回字典中键 key 对应的值，如果没有这个键，返回 default 指定的值（默认是 None ）。
a = {}
a["one"] = "this is number 1"
a["two"] = "this is number 2"
#索引不存在的键值会报错：
#print(a["three"]) #KeyError: 'three'
#改用get方法：
print(a.get("three")) #None
#指定默认值参数：
print(a.get("three", "undefined")) #'undefined'

'2、pop 方法删除元素'
#pop 方法可以用来弹出字典中某个键对应的值，同时也可以指定默认参数：
'd.pop(key, default = None)'
#删除并返回字典中键 key 对应的值，如果没有这个键，返回 default 指定的值（默认是 None ）。
print(a) #{'one': 'this is number 1', 'two': 'this is number 2'}
#弹出并返回值：
print(a.pop("two")) #'this is number 2'
print(a) #{'one': 'this is number 1'}
#弹出不存在的键值：
print(a.pop("two", 'not exist')) #'not exist'
#与列表一样，del 函数可以用来删除字典中特定的键值对，例如：
del a["one"]
print(a) #{}

'3、update方法更新字典'
#之前已经知道，可以通过索引来插入、修改单个键值对，但是如果想对多个键值对进行操作，这种方法就显得比较麻烦，好在有 update 方法：
'd.update(newd)'
#将字典newd中的内容更新到d中去。
person = {}
person['first'] = "Jmes"
person['last'] = "Maxwell"
person['born'] = 1831
print(person) #{'born': 1831, 'last': 'Maxwell', 'first': 'Jmes'}
#把'first'改成'James'，同时插入'middle'的值'Clerk'：
person_modifications = {'first': 'James', 'middle': 'Clerk'}
person.update(person_modifications)
print(person) #{'middle': 'Clerk', 'born': 1831, 'last': 'Maxwell', 'first': 'James'}

'4、in查询字典中是否有该键'
barn = {'cows': 1, 'dogs': 5, 'cats': 3}
#in 可以用来判断字典中是否有某个特定的键：
print('chickens' in barn)  #False
print('cows' in barn)  #True

'5、keys 方法，values 方法和items 方法'
#d.keys():返回一个由所有键组成的列表；
#d.values():返回一个由所有值组成的列表；
#d.items():返回一个由所有键值对元组组成的列表；
print(barn.keys()) #['cows', 'cats', 'dogs']
print(barn.values()) #[1, 3, 5]
print(barn.items()) #[('cows', 1), ('cats', 3), ('dogs', 5)]

六、集合（set）

之前看到的列表和字符串都是一种有序序列，而集合 set 是一种无序的序列。

因为集合是无序的，所以当集合中存在两个同样的元素的时候，Python只会保存其中的一个（唯一性）；同时为了确保其中不包含同样的元素，集合中放入的元素只能是不可变的对象（确定性）。

1、集合生成

可以用set()函数来显示的生成空集合，也可以使用一个列表来初始化一个集合。

'1、set()创建集合'
#可以用set()函数来显示的生成空集合：
a = set()
print(type(a))  #<class 'set'>
'2、用列表来初始化集合'
a = set([1, 2, 3, 1])
print(a) #{1, 2, 3}   #集合会自动去除重复元素 1。
'3、用{}的形式来创建集合'
#可以看到，集合中的元素是用大括号{}包含起来的，这意味着可以用{}的形式来创建集合:
a = {1, 2, 3, 1}
print(a)  #{1, 2, 3}
#但是创建空集合的时候只能用set来创建，因为在Python中{}创建的是一个空的字典：
s = {}
print(type(s)) #<class 'dict'>

2、集合操作

#假设有这样两个集合：
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
'1、并 a.union(b) 或 a | b '
#两个集合的并，返回包含两个集合所有元素的集合（去除重复）。
#可以用方法 a.union(b) 或者操作 a | b 实现。
print(a.union(b)) #{1, 2, 3, 4, 5, 6}
print(b.union(a)) #{1, 2, 3, 4, 5, 6}
print(a | b) #{1, 2, 3, 4, 5, 6}
'2、交  a.intersection(b) 或 a & b'
#两个集合的交，返回包含两个集合共有元素的集合。
#可以用方法 a.intersection(b) 或者操作 a & b 实现。
print(a.intersection(b)) #{3, 4}
print(b.intersection(a)) #{3, 4}
print(a & b) #{3, 4}
'3、差 a.difference(b) 或 a - b '
#a 和 b 的差集，返回只在 a 不在 b 的元素组成的集合。
#可以用方法 a.difference(b) 或者操作 a - b 实现。
print(a.difference(b))  #{1, 2}
print(a - b) #{1, 2} #注意，a - b 与 b - a并不一样，b - a 返回的是返回 b 不在 a 的元素组成的集合：
'4、对称差(补)  a.symmetric_difference(b) 或 a ^ b'
#a 和b 的对称差集，返回在 a 或在 b 中，但是不同时在 a 和 b 中的元素组成的集合。
#可以用方法 a.symmetric_difference(b) 或者操作 a ^ b 实现（异或操作符）。
print(a.symmetric_difference(b))  #{1, 2, 5, 6}
print(b.symmetric_difference(a))  #{1, 2, 5, 6}
print(a ^ b) #{1, 2, 5, 6}
'5、包含关系 b.issubset(a) 或 b <= a '
#假设现在有这样两个集合：
a = {1, 2, 3}
b = {1, 2}
#要判断 b 是不是 a 的子集，可以用 b.issubset(a) 方法，或者更简单的用操作 b <= a ：
print(b.issubset(a)) #True
print(b <= a)  #True
#与之对应，也可以用 a.issuperset(b) 或者 a >= b 来判断：
print(a.issuperset(b)) #True
print(a >= b) #True
#方法只能用来测试子集，但是操作符可以用来判断真子集：
print(a <= a) #True 
#自己不是自己的真子集：
print(a < a)  #False

3、集合方法

'1、add 方法向集合添加单个元素'
#跟列表的 append 方法类似，用来向集合添加单个元素。
#s.add(a):将元素 a 加入集合 s 中。
t = {1, 2, 3}
t.add(5)
print(t) #{1, 2, 3, 5}
#如果添加的是已有元素，集合不改变：
t.add(3)
print(t) #{1, 2, 3, 5}
'2、update 方法向集合添加多个元素'
#跟列表的extend方法类似，用来向集合添加多个元素。
#s.update(seq):将seq中的元素添加到s中。
t.update([5, 6, 7])
print(t) #{1, 2, 3, 5, 6, 7}
'3、remove 方法移除单个元素'
#s.remove(ob):从集合s中移除元素ob，如果不存在会报错。
t.remove(1)
print(t) #{2, 3, 5, 6, 7}
#print(t.remove(10)) #KeyError: 10
'4、pop方法弹出元素'
#由于集合没有顺序，不能像列表一样按照位置弹出元素，所以pop 方法删除并返回集合中任意一个元素，如果集合中没有元素会报错。
print(t.pop()) #2 
print(t)  #{3, 5, 6, 7}
set([3, 5, 6, 7])
s = set()
#s.pop() #KeyError: 'pop from an empty set'
'5、discard 方法'
#作用与 remove 一样，但是当元素在集合中不存在的时候不会报错。
t.discard(3)
print(t) #{5, 6, 7}
#不存在的元素不会报错：
t.discard(20)
print(t) #{5, 6, 7}
'6、difference_update方法'
#从a中去除所有属于b的元素
a.difference_update(b)