Python中的数据类型：数字、字符串、列表、字典、元组、集合及相应操作

数据类型分类

• 数字（number）
• 字符串（string）
• 列表（list）
• 字典（dictionary）
• 元组（tuple）
• 集合（sets）

数字

• 整型（int，integer）

  • Python3中只有一种整数类型int，表示为长整型，没有Python2中的long；

  • 可以表示正数、负数和零；

  • 进制：

    • 默认使用十进制；
    • 使用起始标记后输出时转化为十进制；

    进制	起始	基本数
    二进制	0b	0~9
    八进制	0o	0~7
    十六进制	0x	0~9,A~F

• 浮点型（float）
  • 组成：整数部分+小数部分；
  • 储存不精确：
    • 使用浮点数计算时，可能会出现小数位不确定的情况；

      print (1.1+2.2)
      print (1.1+2.1)
      

      两次结果可能不同，第一次3.3000003，第二次3.2
    • 解决方案：导入模块decimal；

      from decimal import Decimal
      print (Decimal("1.1")+Decimal("2.2"))
      

      结果为3.3
  • 对小数位做保留n位处理：

    a = 0.111111
    b = "%.2f"%a
    print(a,b)
    

    此时输出结果为：

    0.111111 0.11
    

• 布尔型（bool，Boolean）
  • 用来表示真或者假的值；
  • 区别于其他语言：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1，False==0 会返回 True，但可以通过 is 来判断类型；
    • 举例：

      print(1 == True)
      

      输出结果为：

      True
      

      print(1 is True)
      

      输出结果为：

      False
      

  • 可转化为整数；

    print(True+1)
    

    结果为2
• 复数型（complex）
  • 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点。

字符串

• 用单引号 ’ 、双引号 "或者三引号’''定义；
  • 用单双引号定义的字符串必须在同一行；
  • 用三引号定义的字符串可以分布在连续的多行；
• 使用反斜杠 \ 转义特殊字符（即转义字符）或者用作续行符；
• 没有单独的字符类型，一个字符就是长度为1的字符串；
• 区别于其他语言，Python语言中字符串不能被改变，比如对某个索引位置赋值，会导致错误。
• 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。

字符串的驻留机制

• 仅保留一份相同且不可变字符串的方法；
• 不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份数据，在后续创建相同的字符串时，不会开辟新的内存空间，而是将唯一一份数据的地址赋给新创建的变量；
• 调用sys.intern()方法强制多个字符串指向同一个对象；
• 在需要进行字符串的拼接时建议使用join()方法，而不是+；
  • 因为join()方法是先计算出所有字符串的长度，然后再拷贝，只需要新建一次对象，效率更高；

驻留机制发生的几种情况

• 字符串的长度为0或1时；
• 仅由字母、数字、下划线组成的字符串；
• 对于[-5,256]之间的整数数字，Python默认驻留；
• 字符串只在编译时进行驻留，而非运行时。
• 用乘法得到的字符串，如果结果长度<=20且字符串只包含数字、字母、下划线，支持驻留。长度>20，不支持驻留。

驻留机制的优缺点

• 当需要值相同的字符串时，可以直接从驻留池中取用，避免了频繁的创建和销毁，提升效率和节约内存；
• 但同时拼接字符串和修改字符串会影响性能。

字符串的索引值

• 索引值以0为开始值，向后递增1；
• -1为从末尾的开始位置，向前递减1。

字符串的查询操作

• 调用index()方法；
  • 查找子串第一次出现的位置；
  • 如果查找的子串不存在，则抛出ValueError；
• 调用reindex()方法；
  • 查找子串最后一次出现的位置；
  • 如果查找的子串不存在，则抛出ValueError；
• 调用find()方法；
  • 查找子串第一次出现的位置；
  • 如果查找的子串不存在，则返回-1；
• 调用rfind()方法；
  • 查找子串最后一次出现的位置；
  • 如果查找的子串不存在，则返回-1；

字符串的比较操作

• 使用比较操作符；
• 自首位开始比较，相同时比较下一位；直至两字符不相等时得出结果或直至末位得出结果；
• 比较依据：使用对应的原始值比较；
  • 调用ord(X)函数可以得到指定字符的原始值；
  • 调用char(num)函数可以得到对应于原始值的字符；
• 判断id（在内存中的地址）是否相等使用is或is not语句

字符串的更改操作

• replace(old, new[, max])方法；
  • old：将被替换的子字符串；
  • new：新字符串，用于替换old子字符串；
  • max：可选字符串, 替换不超过max次；

字符串的合并操作

• 使用加号+连接字符串；
• 使用join()方法合并字符串：
  • 举例：

    str="-";
    seq=("a","b","c");
    print(str.join(seq));
    //使用str中的值连接seq中的元素
    

    输出结果为

    a-b-c
    

字符串内容对齐操作

• center(width[, fillchar])方法：
  • 居中对齐；
  • 第一个参数为指定宽度，如果设定宽度小于实际宽度，则返回原字符串；
  • 第二个参数为指定填充符，默认为空格；
• rjust(width[, fillchar])方法；
  • 右对齐；
  • 第一个参数为指定宽度，如果设定宽度小于实际宽度，则返回原字符串；
  • 第二个参数为指定填充符，默认为空格；
• ljust(width[, fillchar])方法；
  • 左对齐；
  • 第一个参数为指定宽度，如果设定宽度小于实际宽度，则返回原字符串；
  • 第二个参数为指定填充符，默认为空格；
• zfill(width)方法；
  • 字符串右对齐，并在前面补充0；
  • 参数为指定宽度，如果设定宽度小于实际宽度，则返回原字符串；；

字符串的劈分操作

• split(str, num)方法；
  • 自左向右劈分；
  • 返回值为一个列表；
  • 第一个参数为分隔符，默认为空字符，包括空格、换行(\n)、制表符(\t)等；
  • 第二个参数为分割次数。默认为-1, 即分隔所有；经过最大劈分次数后剩余的子串会单独作为一部分；
• rsplit(str, num)方法
  • 自右向左劈分；
  • 返回值为一个列表；
  • 第一个参数为分隔符，默认为空字符，包括空格、换行(\n)、制表符(\t)等；
  • 第二个参数为分割次数。默认为-1, 即分隔所有；经过最大劈分次数后剩余的子串会单独作为一部分；

字符串的切片操作

• 语法格式：

  str[start:stop:step]
  

  • 当未指定参数时，默认从首位开始，末位结束，步长为一；
  • 当步长为负数时，从后向前切片；
• 切片操作将产生新的对象；

字符串大小写转换操作

• capitalize()
  • 将字符串的第一个字符转换为大写；
• title()
  • 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写；
• upper()
  • 转换字符串中的小写字母为大写；
• lower()
  • 转换字符串中所有大写字符为小写；
• swapcase()
  • 将字符串中大写转换为小写，小写转换为大写；

字符串的判断操作

• isidentifier()
  • 判断指定字符串是否为合法的标识符；
• isspace()
  • 判断指定字符串是否全部由空白字符组成；
• isalpha()
  • 判断指定字符串是否全部由字母（包括汉字）组成；
• isdecimal()
  • 判断指定字符串是否全部由十进制（只认阿拉伯数字）组成；
• isnumeric()
  • 判断指定字符穿是否全部由数字（任何语言的数字）组成；
• isalnum()
  • 判断指定字符穿串是否全部由字母（包括汉字）和数字组成；

格式化字符串

• 在Python中字符串格式化与C语言中printf()函数语法相同；
• 占位符：
  • 使用%做占位符；
    • 语法格式：

      print("格式化符号"%(实际值))
      

    • 格式化符号：

      符号	描述	举例
      %s	格式化字符串
      %d	格式化整数，可指定宽度	%10d：宽度为10， 位数不够时自左用空格填充
      %f	格式化浮点数字，可指定小数点后的精度	%10.3d：宽度为10， 保留小数点后3位， 小数位数不够时向右用0填充
      %e	用科学计数法格式化浮点数

  • 使用{}做占位符；
    • 语法格式：

      print("{0}{1}".format(实际值1,实际值2))
      

    • 举例：

      print("{0:.1}".format(3.1415926))
      print("{0:.3f}".format(3.1415926))
      print("{0:10.3f}".format(3.1415926))
      

      输出结果为：

      3e+00
      //“e+00”表示10的0次方
      3.142
           3.142
      

字符串的编码与解码

• 编码：
  • 语法格式：

    str.encode([encoding=""][,errors=""])
    

  • 指定进行编码时采用的字符编码，该选项默认采用utf-8 编码。例如，如果想使用简体中文，可以设置 gb2312；当方法中只使用这一个参数时，可以省略前边的“encoding=”，直接写编码格式，例如str.encode(“UTF-8”)；
  • errors指定错误处理方式，其可选择值可以是：
    • strict：遇到非法字符就抛出异常；
    • ignore：忽略非法字符；
    • replace：用“？”替换非法字符；
    • xmlcharrefreplace：使用 xml 的字符引用；
    • 该参数的默认值为 strict；
• 解码：
  • 语法格式：

    bytes.decode([encoding="utf-8"][,errors="strict"])
    

  • 指定解码时采用的字符编码，默认采用 utf-8 格式。当方法中只使用这一个参数时，可以省略“encoding=”，直接写编码方式即可；
  • 注意，对bytes类型数据解码，要选择和当初编码时一样的格式。
  • errors指定错误处理方式，其可选择值可以是：
    • strict：遇到非法字符就抛出异常；
    • ignore：忽略非法字符；
    • replace：用“？”替换非法字符；
    • xmlcharrefreplace：使用 xml 的字符引用；
    • 该参数的默认值为 strict；

转义字符

• 定义：反斜杠+想要实现的转义功能首字母。
• 用途（为什么需要转义字符）：
  • 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用转义字符对这些字符进行转义（转换一个含义），举例：
    • 反斜杠\\

      print('http:\\www.baidu.com')
      

      输出结果为：

      http:\www.baidu.com
      

    • 单引号\’
    • 双引号\"
  • 当字符串中包含回车、换行、水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符。举例：
    • 换行\n (newline)

      print('Hello\nworld!')
      

      输出结果为：

      Hello
      world!
      

    • 回车\r (return)，会使后面的内容覆盖前面的内容；

      print('Hello\rworld!')
      

      输出结果为：

      world!
      

    • 水平制表符\t (tab)，输出结果为占据下一个制表位（四个空格）剩余位置的间隔；

      print('Hello\tworld!')
      

      输出结果为：

      Hello   world!//中间实际上只有三个空格的位置
      

    • 退格\b (backspace)，退一个格继续输出

      print('Hello\bworld!')
      

      输出结果为：

      Hellworld!
      

原字符

• 定义：不希望字符串中的转义字符生效时，使用原字符；
• 操作：在字符串前加上“r”或“R”；
• 注意：使用原字符时，后接字符串的最后一位不能为反斜线，连续两（偶数）个反斜杠可以；
• 举例：

  print(r'Hello\nworld!')
  

  输出结果为：

  Hello\nworld!
  

列表

• 是Python中最基本的数据结构；
• 相当于其他语言中的数组；

特点

• 元素按顺序有序排列；
• 索引映射唯一的数据；
• 可以重复存储数据；
• 任意数据类型混存；
• 根据需要动态分配和回收内存。

创建列表

• 方法一：使用中括号[]，元素之间用英文逗号“,”分隔开；
  • 举例：

    list_1=['red','green','blue']
    

• 方法二：调用内置函数list()；
  • 举例：

    list_1=list(['red','green','blue'])
    

• 方法三：列表生成式；
  • 语法格式：

    [变量表达式 for 变量 in range(start,stop,step)]
    

  • 举例：

    list=[i*i for i in range(0:5:2)]
    

    相当于：

    [0, 4, 16]
    

获取指定元素的索引

• 调用index()方法：
  • 如果列表中存在N个相同的元素，只返回相同元素中的第一个元素值的索引；
  • 如果查询的元素在列表中不存在，则抛出

    ValueError:'X' is not in list 
    

  • 可以在指定的start和stop之间进行查找；
• 举例：
  • 例一：

    list=['red','green','blue','yellow','white','black']
    print(list.index("red",1,5))
    

    抛出：

    ValueError:'red' is not in list 
    

  • 例二：

    list=['red','green','blue','yellow','white','black']
    print(list.index("red"))
    

    输出结果为：

    0
    

获取列表中的元素

• 与字符串类似，列表中的每个值都有对应的位置值，称之为索引;
• 通过索引列表可以进行截取、组合等操作。
• 从前向后，列表第一个位置的索引是0，向后递增1；
• 从后向前，列表最后一个位置的索引是-1，向前递减1；
• 指定的索引不存在时，抛出indexError.
  • 举例：
    • 例一：

      list=['red','green','blue','yellow','white','black']
      print(list[0])
      print(list[1])
      print(list[2])
      

      输出结果为：

      red
      green
      blue
      

    • 例二：

      list=['red','green','blue','yellow','white','black']
      print(list[-1])
      print(list[-2])
      print(list[-3])
      

      输出结果为：

      black
      white
      yellow
      

• 获取多个元素(切片)：
  • 语法格式：

    list[start:stop:step]
    

  • 切片的结果；原列表中片段的拷贝；
  • 切片的范围：[start,stop)；
  • step：
    • 默认值为1；
    • 当值为正数时，从start开始的向后切片；
      • [:stop:step]切片的第一个元素默认时列表的第一个元素；
      • [start::step]切片的最后一个元素默认是列表的最后一个元素；
    • 当值为负数时，其余两参数也对应为负数，从start开始的向前切片；
      • [:stop:step]切片的最后一个元素默认是列表的第一一个元素；
      • [start::step]；切片的第一个元素默认时列表的最后一个元素；

判断指定元素在列表中是否存在

• 语法结构：
  • 元素 in 列表名；
  • 元素 not in 列表名；

增加列表元素

• append()方法；
  • 在列表的末尾添加一个元素；
  • 举例：

    list=['red','green','blue']
    list.append('yellow')
    print(list)
    

    输出结果为：

    ['red','green','blue','yellow']
    

• extend()方法；
  • 在列表的末尾至少添加一个元素；
  • 举例：

    list_1=['red','green','blue']
    list_2=['yellow','white','black']
    list_1.extend(list_2)
    print(list_1)
    

    输出结果为：

    ['red','green','blue','yellow','white','black']
    

• insert()方法；
  • 在列表的任意位置添加一个元素；
  • 举例：

    list=['red','green','blue']
    list.insert(1,'yellow')
    print(list)
    

    输出结果为：

    ['yellow','red','green','blue']
    

• 切片；
  • 在列表的任意位置至少添加一个元素；
  • 举例：

    list_1=['red','green','blue']
    list_2=['yellow','white','black']
    list_1[3:]=list_2
    //list_1的元素从第四个位置开始切换为list_2的全部元素
    print(list_1)
    

    输出结果为：

    ['red','green','blue','yellow','white','black']
    

删除列表元素

• 使用del语句来删除列表的元素或者删除整个列表：
  • 举例：
    • 例一：

      list=['red','green','blue']
      del list[1]
      print(list)
      

      输出结果为：

      ['green','blue']
      

    • 例二：

      list_1=['red','green','blue']
      del list_1
      print(list_1)
      

      输出结果为：

      NameError: name 'list_1' is not defined.
      

• remove()方法：
  • 一次删除一个元素；
  • 重复元素只删除第一个；
  • 元素不存在时抛出ValueError;
  • 举例：

    list=['red','green','blue']
    list.remove["red"]
    print(list)
    

    输出结果为：

    ['green','blue']
    

• pop()方法：
  • 删除一个指定索引位置上的元素；
  • 指定索引不存在时抛出IndexError；
  • 不指定索引时删除列表中的最后一个元素；
  • 举例：

    list=['red','green','blue']
    temp=list.pop(1)
    print(list)
    print(temp)
    

    输出结果为：

    ['red', 'blue']
    green
    

• 切片：
  • 一次最少删除一个元素；
  • 举例：

    list=['red','green','blue']
    list[1:2]=""
    print(list)
    

    输出结果为：

    ['red', 'blue']
    

• clear()：
  • 清空列表元素；
  • 举例：

    list=['red','green','blue']
    list.clear()
    print(list)
    

    输出结果为：

    []
    

更改列表元素

• 对列表中指定索引的元素重新赋值；
  • 举例：

    list=['red','green','blue']
    list[1]='yellow'
    print(list)
    

    输出结果为：

    ['yellow','green','blue']
    

• 对列表中指定切片重新赋值；
  • 举例：

    list_1=['red','green','blue']
    list_2=['yellow','white','black']
    list_1[1:]=list_2
    print(list_1)
    

    输出结果为：

    ['red', 'yellow', 'white', 'black']
    

列表元素的排序操作

• 调用sort()方法；
  • 默认为从小到大的顺序进行排序；
  • 可以指定"reverse=True"，进行降序排序；
  • 不生成新列表，在原列表的内存空间进行操作；
  • 举例：

    list=[1,8,5,3,5,7,7]
    list.sort()
    print(list)
    list.sort(reverse=True)
    print(list)
    

    输出结果为：

    [1, 3, 5, 5, 7, 7, 8]
    [8, 7, 7, 5, 5, 3, 1]
    

• 调用内置函数sorted()；
  • 可以指定"reverse=True"，进行降序排序，原列表不发生改变；
  • 生成新的列表对象；
  • 语法结构：

    sorted(iterable, key=None, reverse=False)  
    

    • iterable：可迭代对象；
    • key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序；
    • reverse：排序规则，reverse = True 降序 ， reverse = False 升序（默认）；
  • 举例：

    list_1=[1,8,5,3,5,7,7]
    list_2=sorted(list_1,reverse=True)
    print(list_2)
    

    输出结果为：

    [8, 7, 7, 5, 5, 3, 1]
    

• 调用reverse()方法：
  • 无返回值，对列表元素反向排序；
  • 不生成新列表，在原列表的内存空间进行操作；

字典

• 一种可变容器模型，可以存储任意类型的对象；
• 以键值对的方式存储数据；
• 字典是一个无序的序列；
• 键必须是唯一的，但值则不必
• 存储时使用哈希函数计算存储位置，这也就要求key为不可变序列；
• 值可以取任何数据类型，但键必须是不可变的，如字符串，数字；
• 会浪费较大的内存，是一种空间换时间的数据结构；

创建字典

• 方法一：

  dict={key1:value1,key2:value2,key3:value3}
  

  • 每个键值key=>value对用冒号: 分割，每个对之间用逗号,分割，整个字典包括在花括号{}中；；
  • 举例：

    dict={'name':'Lee','age':24}
    

    dict={}
    //空字典
    

• 方法二：使用内置函数dict()

  dict_1=dict(name="Lee",age=25)
  

• 方法三：使用内置函数zip()以及字典生成式
  • zip()函数用于将可迭代的对象作为参数，将对象中的对应的元素打包成一个元组，然后返回由这些元素组成的列表；
  • 语法格式：

    dict={表示字典key的变量:表示字典value的变量 for 表示字典key的变量,表示字典value的变量 in zip(字典key所在对象,字典value所在对象)}
    

  • 举例：

    items=['name','age']
    prices=["lee",24]
    dict={item:price for item,price in zip(items,prices)}
    print(dict)
    

    输出结果为：

    {'name': 'lee', 'age': 24}
    

获取字典中的元素

• 使用[]取值：
  • 如果字典中不存在指定的key，则抛出keyError；
• 调用get()方法取值：
  • 如果字典中不存在指定的key，将返回None；
  • 通过参数设置不存在时返回的值；
  • 举例：

    dict={'Name':'Lee','Age':24}
    print('Salary:',dict.get('Salary'))
    

    此时由于没有设置Salary，将输出：

    Salary:None
    

判断给定的key是否在字典中

• 使用in与not in进行判断；

字典元素的删除

• 使用del语句；
  • 举例

    dict={'Name':'Lee','Age':24}
    del dict["Name"]
    print(dict)
    

    输出结果为：

    {'Age': 24}
    

• 调用clear()方法清空字典元素：
  • 举例

    dict={'Name':'Lee','Age':24}
    dict.clear()
    print(dict)
    

    输出结果为：

    {}
    

字典元素的新增

• 增加新的键值对；
• 举例

  dict={'Name':'Lee','Age':24}
  dict["Salary"]=0.0
  print(dict)
  

  输出结果为：

  {'Name': 'Lee', 'Age': 24, 'Salary': 0.0}
  

字典元素的更改

• 对已有键值对进行修改；
• 举例

  dict={'Name':'Lee','Age':24}
  dict["Age"]=25
  print(dict)
  

  输出结果为：

  {'Name': 'Lee', 'Age': 25}
  

获取字典视图

• 视图对象都是只读的；
• 字典改变，视图也会跟着改变；
• 获取方法：
  • keys()方法：获取字典中所有的key；
  • values()方法：获取字典中所有的value；
  • items()方法；获取字典中所有的键值对；

字典元素的遍历

• 举例：

  dict={'Name':'Lee','Age':24}
  for item in dict:
      print(item,dict[item])
  

  输出结果为：

  Name Lee
  Age 24
  

元组

• python内置的数据结构之一，是一个不可变序列，即元组的元素不能修改；
• 元组中存储的时对象的引用：
  • 元组中的对象是不可变序列时，不可改为引用其他对象；
  • 元组中的对象是可变序列时，不可改为引用其他对象，但该可变序列的数据可以改变。
• 元组的索引、截取操作与字符串基本相同；

为什么将元组设置为不可变序列

• 在多任务环境下，同时操作对象时不需要加锁；

元组的创建

• 在()内添加元素，并使用逗号隔开；
• 注意：元组内只有一个元素时，需要在元素后面添加逗号, ，否则括号会被当作运算符使用；
• 举例：
  • 例一：

    tuple=('Lee',25)
    

  • 例二：

    tuple=()
    //创建空元组
    

访问元组中的值

• 下标索引从0开始，利用索引可以进行截取、组合等操作；
• 举例：

  tuple=('Lee',25)
  print(tuple[1])
  

  输出结果为：

  25
  

修改元组

• 元组中元素值不允许修改，但可以对元组进行连接组合；
• 举例：

  tuple_1=('Lee',)
  tuple_2=(25,)
  tuple_3=tuple_1+tuple_2
  print(tuple_1)
  

  输出结果为：

  ('Lee',25)
  

删除元组

• 元组中的元素不允许删除，但可以使用del语句来删除整个元组：
• 举例：

  tuple_1=('Lee',25)
  del tuple_1
  print(tuple_1)
  

  输出结果显示

  NameError: name 'tuple_1' is not defined
  

元组的遍历

tuple=('Lee',25)
for item in tuple:
    print(item)

输出结果为：

Lee
25

集合

• 是一个无序的不重复元素序列；
• 存储时使用哈希函数计算存储位置；

创建集合

• 方法一：使用{}；
  • 不可用于创建空集合；
  • 语法格式：

    parame = {value01,value02,...}
    

• 方法二：使用set()函数进行强制转换；
  • 语法格式：

    set(value)
    

  • 举例：

    name=set('lee')
    num_1=set([1,85,35,7,7])
    num_2=set((1,85,35,7,7))
    num_2=set((1,85,35,7,7))
    num_3=set({1,85,35,7,7})
    print(name)
    print(num_1)
    print(num_2)
    print(num_3)
    

    输出结果为：

    {'l', 'e'}
    {1, 35, 85, 7}
    {1, 35, 85, 7}
    {1, 35, 85, 7}
    

判断元素是否存在

• 使用in与not in判断

添加元素

• 调用add()方法；
  • 语法格式：

    set.add(x)
    

  • 如果元素已存在，则不进行任何操作；
• 调用update()方法；
  • 语法格式：

    set.update(X,X,X,X)
    

  • 参数可以为列表、元组、字典等；

移除元素

• 调用remove()方法；
  • 当元素不在该集合中时，抛出KeyError；
• 调用discard()方法；
• 调用pop()方法；
  • 随机删除元素，无法指定元素；
• 调用clear()方法；
  • 清空整个集合；

集合之间的关系

• 相等：使用==或!=进行判断；
• 是否为另一个集合的自子集：调用issubset()方法进行判断；
• 是否为另一个集合的超集：调用issuperset()方法进行判断；
• 两个集合是否没有交集：调用isdisjoint()方法进行判断；

集合的数学操作

• difference()，返回集合的差集；
• intersection()，返回集合的交集；
• union()，返回集合的并集；
• symmetric_difference()，返回集合的对称差集；
• |，两集合中包含的所有元素；
• &，两集合中都包含的元素；
• ^，不同时包含于两集合中的元素；
• -，前一集合中包含，而后一集合中没有的元素；

集合生成式

• 语法结构：

  {变量表达式 for 变量 in range(start,stop,step)}