Python sys模块用法详解
sys 是一个和 Python 解释器关系密切的标准库，它和帮助我们访问和 Python 解释器联系紧密的变量和函数
| sys成员（变量和函数） | 功能描述 |
|---|---|
| sys.argv | 获取运行 Python 程序的命令行参数。其中 sys.argv[0] 通常就是指该 Python 程序，sys.argv[1] 代表为 Python 程序提供的第一个参数，sys.argv[2] 代表为 Python 程序提供的第二个参数……依此类推。 |
| sys.path | 是一个字符串列表，其中每个字符串都是一个目录名，在使用 import 语句导入模块时，解释器就会从这些目录中查找指定的模块。 |
| sys.exit() | 通过引发 SystemExit 异常来退出程序。将其放在 try 块中不能阻止 finally 块的执行。你可以提供一个整数作为参数（默认为 0 ，标识成功），用来标识程序是否成功运行，这是 UNIX 的一个惯例。 |
| sys.modules | 返回模块名和载入模块对应关系的字典。 |
| sys.platform | 此变量是一个字符串，标识解释器当前正在运行的平台名称，它可能是标识操作系统的名称，也可能是标识其他种类的平台，如果运行 Jython 的话，就是 Java 虚拟机。 |
| sys.stdin、sys.stdout、sys.stderr | 这三个模块变量是类文件流对象，分别表示标准输入、标准输出和标准错误。简单理解，Python 利用 sys.stdin 获得输入，利用 sys.stdout 输出。 |
| sys.flags | 该只读属性返回运行 Python 命令时指定的旗标。 |
| sys.getfilesystemencoding() | 返回在当前系统中保存文件所用的字符集。 |
| sys.getrefcount(object) | 返回指定对象的引用计数。前面介绍过，当 object 对象的引用计数为 0 时，系统会回收该对象。 |
| sys.getrecursionlimit() | 返回 Python 解释器当前支持的递归深度。该属性可通过 setrecursionlimit() 方法重新设置。 |
| sys.getswitchinterval() | 返回在当前 Python 解释器中线程切换的时间间隔。该属性可通过 setswitchinterval() 函数改变。 |
| sys.implementation | 返回当前 Python 解释器的实现。 |
| sys.maxsize | 返回 Python 整数支持的最大值。在 32 位平台上，该属性值为 2**31-1；在 64 位平台上，该属性值为 2**63-1。 |
| sys.executable | 该属性返回 Python 解释器在磁盘上的存储路径。 |
| sys.byteorder | 显示本地字节序的指示符。如果本地字节序是大端模式，则该属性返回 big；否则返回 little。 |
| sys.copyright | 该属性返回与 Python 解释器有关的版权信息。 |
| sys.version | 返回当前 Python 解释器的版本信息。 |
| sys.winver | 返回当前 Python 解释器的主版本号。 |
Python os模块及用法
os 模块代表了程序所在的操作系统，主要用于获取程序运行所在操作系统的相关信息。
在 Python 的交互式解释器中先导入 os 模块，然后输入 os.__all__ 命令（__all__ 变量代表了该模块开放的公开接口），即可看到该模块所包含的全部变量和函数。
开发者同样不需要完全记住这些变量和函数的含义，在需要用时可参考https://docs.python.org/3/library/os.html。
| os 成员（变量、函数和类） | 功能描述 |
|---|---|
| os.name | 返回导入依赖模块的操作系统名称，通常可返回 'posix'、'nt'、 'java' 等值其中之一。 |
| os.environ | 返回在当前系统上所有环境变量组成的字典。 |
| os.sep | 返回路径分隔符。 |
| os.fsencode(filename) | 该函数对类路径（path-like）的文件名进行编码。 |
| os.fsdecode(filename) | 该函数对类路径（path-like）的文件名进行解码。 |
| os.PathLike | 这是一个类，代表一个类路径（path-like）对象。 |
| os.getenv(key, default=None） | 获取指定环境变量的值。 |
| os.getlogin() | 返回当前系统的登录用户名。与该函数对应的还有 os.getuid()、os.getgroups()、os.getgid() 等函数，用于获取用户 ID、用户组、组 ID 等，这些函数通常只在 UNIX 系统上有效。 |
| os.getpid() | 获取当前进程 ID。 |
| os.getppid() | 获取当前进程的父进程 ID。 |
| os.putenv(key, value) | 该函数用于设置环境变量。 |
| os.cpu_count() | 返回当前系统的 CPU 数量。 |
| os.pathsep | 返回当前系统上多条路径之间的分隔符。一般在 Windows 系统上多条路径之间的分隔符是英文分号（;）；在 UNIX 及类 UNIX 系统（如 Linux、Mac os X）上多条路径之间的分隔符是英文冒号（:）。 |
| os.linesep | 返回当前系统的换行符。一般在 Windows 系统上换行符是“\r\n”：在 UNIX 系统上换行符是“\n”；在 Mac os X 系统上换行符是“\r”。 |
| os.urandom(size) | 返回适合作为加密使用的、最多由 N 个字节组成的 bytes 对象。该函数通过操作系统特定的随机性来源返回随机字节，该随机字节通常是不可预测的，因此适用于绝大部分加密场景。 |
| os进程管理函数 | 功能描述 |
|---|---|
| os.system(command) | 运行操作系统上的指定命令。 |
| os.abort() | 生成一个 SIGABRT 信号给当前进程。在 UNIX 系统上，默认行为是生成内核转储；在 Windows 系统上，进程立即返回退出代码 3。 |
| os.execl(path, arg0, arg1, ...） | 该函数还有一系列功能类似的函数，比如 os.execle()、os.execlp() 等，这些函数都是使用参数列表 arg0, arg1,...来执行 path 所代表的执行文件的。由于 os.exec*() 函数都是 PosIX 系统的直接映射，因此如采使用该命令来执行 Python 程序，传入的 arg0 参数没有什么作用。os._exit(n) 用于强制退出 Python 解释器。将其放在 try 决中可以阻止 finally 块的执行。 |
| os.forkpty() | fork一个子进程。 |
| os.kill(pid, sig) | 将 sig 信号发送到 pid 对应的过程，用于结束该进程。 |
| os.killpg(pgid, sig) | 将 sig 信号发送到 pgid 对应的进程组。 |
| os.popen(cmd, mode='r', buffering=-1) | 用于向 cmd 命令打开读写管道（当 mode 为 r 时为只读管道，当 mode 为 rw 时为读写管道），buffering 缓冲参数与内置的 open() 函数有相同的含义。该函数返回的文件对象用于读写字符串，而不是字节。 |
| os.spawnl(mode, path, ...) | 该函数还有一系列功能类似的函数，比如 os.spawnle()、os.spawnlp() 等，这些函数都用于在新进程中执行新程序。 |
| os.startfile(path[,operation]) | 对指定文件使用该文件关联的工具执行 operation 对应的操作。如果不指定 operation 操作，则默认执行打开（open）操作。operation 参数必须是有效的命令行操作项目，比如 open（打开）、edit（编辑）、print（打印）等。 |
Python random模块及用法
random 模块包括返回随机数的函数，可以用于模拟或者任何产生随机输出的程序。
在 random 模块下提供了表 1 所示的常用函数。
| random模块常用函数 | 功能描述 |
|---|---|
| random.seed(a=None, version=2) | 指定种子来初始化伪随机数生成器。 |
| random.randrange(start, stop[, step]) | 返回从 start 开始到 stop 结束、步长为 step 的随机数。其实就相当于 choice(range(start, stop, step)) 的效果，只不过实际底层并不生成区间对象。 |
| random.randint(a, b) | 生成一个范围为 a≤N≤b 的随机数。其等同于 randrange(a, b+1) 的效果。 |
| random.choice(seq) | 从 seq 中随机抽取一个元素，如果 seq 为空，则引发 IndexError 异常。 |
| random.choices(seq, weights=None, cum_weights=None, k=1) | 从 seq 序列中抽取 k 个元素，还可通过 weights 指定各元素被抽取的权重（代表被抽取的可能性高低）。 |
| random.shuffle(x[, random]) | 对 x 序列执行洗牌“随机排列”操作。 |
| random.sample(population, k) | 从 population 序列中随机抽取 k 个独立的元素。 |
| random.random() | 生成一个从0.0（包含）到 1.0（不包含）之间的伪随机浮点数。 |
| random.uniform(a, b) | 生成一个范围为 a≤N≤b 的随机数。 |
| random.expovariate(lambd) | 生成呈指数分布的随机数。其中 lambd 参数(其实应该是 lambda，只是 lambda 是 Python 关键字，所以简写成 lambd）为 1 除以期望平均值。如果 lambd 是正值，则返回的随机数是从 0 到正无穷大；如果 lambd 为负值，则返回的随机数是从负无穷大到 0。 |
root@kube sys]# cat demo4.py import random #生成范围为0.0≤x<1.0 的伪随机浮点数 print (random.random()) #生成范围为2.5≤x<10.0 的伪随机浮点数 print (random.uniform(2.5, 10.0)) #生成呈指数分布的伪随机浮点数 print (random.expovariate(1/5)) #生成从0 到9 的伪随机整数 print(random.randrange(10)) #生成从0 到100 的随机偶数 print (random.randrange(0, 101 , 2)) #随机抽取一个元素 print (random.choice (['Python','Swift','Kotlin'])) book_list = ['Python','Swift','Kotlin'] #对列表元素进行随机排列 random.shuffle (book_list) print (book_list) #随机抽取4 个独立的元素 print (random.sample([10, 20 , 30 , 40 , 50], k=4)) print (random.randrange(18,32))
#指定随机抽取6 个元素，各元素被抽取的权重（概率）不同
print(random.choices(['Python','Swift','Kotlin'], [5, 5, 1], k=6))
[root@kube sys]#
Python time模块详解
time 模块主要包含各种提供日期、时间功能的类和函数。该模块既提供了把日期、时间格式化为字符串的功能，也提供了从字符串恢复日期、时间的功能。
在 time 模块内提供了一个 time.struct_time 类，该类代表一个时间对象，它主要包含 9 个属性，每个属性的信息如表 1 所示：
| 字段名 | 字段含义 | 值 |
|---|---|---|
| tm_year | 年 | 如 2017、2018 等 |
| tm_mon | 月 | 如 2、3 等，范围为 1~12 |
| tm_mday | 日 | 如 2、3 等，范围为 1~31 |
| tm_hour | 时 | 如 2、3 等，范围为 0~23 |
| tm_min | 分 | 如 2、3 等，范围为 0~59 |
| tm_sec | 秒 | 如 2、3 等，范围为 0~61 |
| tm_wday | 周 | 周一为 0，范围为 0~6 |
| tm_yday | 一年内第几天 | 如 65，范围 1~366 |
| tm_isdst | 夏时令 | 0、1 或 -1 |
注意，秒的范围 0~61 是为了应付闰秒和双闰秒。
在日期、时间模块内常用的功能函数如表 1 所示。
表 1 time模块常用函数 time常用函数 功能描述 time.asctime([t]) 将时间元组或 struct_time 转换为时间字符串。如果不指定参数 t，则默认转换当前时间。 time.ctime([secs]) 将以秒数代表的时间（格林威治时间）转换为时间字符串。 time.gmtime([secs]) 将以秒数代表的时间转换为 struct_time 对象。如果不传入参数，则使用当前时间。 time.localtime([secs]) 将以秒数代表的时间转换为代表当前时间的 struct_time 对象。如果不传入参数，则使用当前时间。 time.mktime(t) 它是 localtime 的反转函数，用于将 struct_time 对象或元组代表的时间转换为从 1970 年 1 月 1 日 0 点整到现在过了多少秒。 time.perf_counter() 返回性能计数器的值。以秒为单位。 time.process_time() 返回当前进程使用 CPU 的时间，以秒为单位。 time.sleep(secs) 暂停 secs 秒，什么都不干。 time.strftime(format[, t]) 将时间元组或 struct_time 对象格式化为指定格式的时间字符串。如果不指定参数 t，则默认转换当前时间。 time.strptime(string[, format]) 将字符串格式的时间解析成 struct_time 对象。 time.time() 返回从 1970 年 1 月 1 日 0 点整到现在过了多少秒。 time.timezone 返回本地时区的时间偏移，以秒为单位。 time.tzname 返回本地时区的名字。 Python 可以用从 1970 年 1 月 1 日 0 点整到现在所经过的秒数来代表当前时间（又称格林威治时间），比如我们写 30 秒，那么意味着时间是 1970 年 1 月 1 日 0 点 0 分 30 秒。但需要注意的是，在实际输出时可能会受到时区的影响，比如中国处于东八区，因此实际上会输出 1970 年 1 月 1 日 8 点 0 分 30 秒。
import time
# 将当前时间转换为时间字符串
print(time.asctime())
# 将指定时间转换时间字符串，时间元组的后面3个元素没有设置
print(time.asctime((2018, 2, 4, 11, 8, 23, 0, 0 ,0))) # Mon Feb 4 11:08:23 2018
# 将以秒数为代表的时间转换为时间字符串
print(time.ctime(30)) # Thu Jan 1 08:00:30 1970
# 将以秒数为代表的时间转换为struct_time对象。
print(time.gmtime(30))
# 将当前时间转换为struct_time对象。
print(time.gmtime())
# 将以秒数为代表的时间转换为代表当前时间的struct_time对象
print(time.localtime(30))
# 将元组格式的时间转换为秒数代表的时间
print(time.mktime((2018, 2, 4, 11, 8, 23, 0, 0 ,0))) # 1517713703.0
# 返回性能计数器的值
print(time.perf_counter())
# 返回当前进程使用CPU的时间
print(time.process_time())
#time.sleep(10)
# 将当前时间转换为指定格式的字符串
print(time.strftime('%Y-%m-%d %H:%M:%S'))
st = '2018年3月20日'
# 将指定时间字符串恢复成struct_time对象。
print(time.strptime(st, '%Y年%m月%d日'))
# 返回从1970年1970年1月1日0点整到现在过了多少秒。
print(time.time())
# 返回本地时区的时间偏移，以秒为单位
print(time.timezone) # 在国内东八区输出-28800
time 模块中的 strftime() 和 strptime() 两个函数互为逆函数，其中 strftime() 用于将 struct_time 对象或时间元组转换为时间字符串；而 strptime() 函数用于将时间字符串转换为 struct_time 对象。这两个函数都涉及编写格式模板，比如上面程序中使用 %Y 代表年、%m 代表月、%d 代表日、%H 代表时、%M 代表分、%S 代表秒。这两个函数所需要的时间格式字符串支持的指令如表 2 所示：
表 2 Python 时间格式字符串所支持的指令 指令 含义 %a 本地化的星期几的缩写名，比如 Sun 代表星期天 %A 本地化的星期几的完整名 %b 本地化的月份的缩写名，比如 Jan 代表一月 %B 本地化的月份的完整名 %c 本地化的日期和时间的表示形式 %d 代表一个月中第几天的数值，范固： 01~31 %H 代表 24 小时制的小时，范围：00~23 %I 代表 12 小时制的小时，范围：01~12 %j 一年中第几天，范围：001~366 %m 代表月份的数值，范围：01~12 %M 代表分钟的数值，范围：00~59 %p 上午或下午的本地化方式。当使用 strptime() 函数并使用 %I 指令解析小时时，%p 只影响小时字段 %S 代表分钟的数值，范围：00~61。该范围确实是 00~61，60 在表示闰秒的时间戳时有效，而 61 则是由于一些历史原因造成的 %U 代表一年中表示第几周，以星期天为每周的第一天，范围：00~53。在这种方式下，一年中第一个星期天被认为处于第一周。当使用 strptime() 函数解析时间字符串时，只有同时指定了星期几和年份该指令才会有效 %w 代表星期几的数值，范围：0~6，其中 0 代表周日 %W 代表一年小第几周，以星期一为每周的第一天，范围：00~53。在这种方式下，一年中第一个星期一被认为处于第一周。当使用 strptime() 函数解析时间字符串时，只有同时指定了星期几和年份该指令才会有效 %x 本地化的日期的表示形式 %X 本地化的时间的表示形式 %y 年份的缩写，范围：00~99，比如 2018 年就简写成 18 %Y 年份的完整形式。如 2018 %z 显示时区偏移 %Z 时区名（如果时区不行在，则显示为空） %% 用于代表%符号
Python json模块完全攻略
JSON 主要有如下两种数据结构：
- 由 key-value 对组成的数据结构。这种数据结构在不同的语言中有不同的实现。例如，在 JavaScript 中是一个对象；在 Python 中是一种 dict 对象；在 C 语言中是一个 struct；在其他语言中，则可能是 record、dictionary、hash table 等。
- 有序集合。这种数据结构在 Python 中对应于列表；在其他语言中，可能对应于 list、vector、数组和序列等。
上面两种数据结构在不同的语言中都有对应的实现，因此这种简便的数据表示方式完全可以实现跨语言。所以，JSON 可以作为程序设计语言中通用的数据交换格式。
在 JavaScript 中主要有两种 JSON 语法，其中一种用于创建对象，另一种用于创建数组。
object =
{
propertyName1 : propertyValue1,
propertyName2 : propertyValue2,
...
}
必须注意的是，并不是在每个属性定义的后面都有英文逗号，必须当后面还有属性定义时才需要有逗号
Python 的JSON 支持
json 模块提供了对 JSON 的支持，它既包含了将 JSON 字符串恢复成 Python 对象的函数，也提供了将 Python 对象转换成 JSON 字符串的函数。
当程序把 JSON 对象或 JSON 字符串转换成 Python 对象时，从 JSON 类型到 Python 类型的转换关系如表 3 所示：
| JSON 类型 | Python 类型 |
|---|---|
| 对象（object） | 字典（dict） |
| 数组（array） | 列表（list） |
| 字符串（string） | 字符串（str） |
| 整数（number(int)） | 整数（int） |
| 实数（number(real)） | 浮点数（float） |
| true | True |
| false | False |
| null | None |
当程序把 Python 对象转换成 JSON 格式字符串时，从 Python 类型到 JSON 类型的转换关系如表 4 所示：
| Python 类型 | JSON 类型 |
|---|---|
| 字典（dict） | 对象（object） |
| 列表（list）和元组（tuple） | 数组（array） |
| 字符串（str） | 字符串（string） |
| 整型、浮点数，以及整型、浮点型派生的枚举（float,int-& float-derived Enums） | 数值型（number） |
| True | true |
| False | false |
| None | null |
在 Python 的交互式解释器中先导入 json 模块，然后输入 json.all 命令，即可看到该模块所包含的全部属性和函数：
>>> json.__all__
['dump', 'dumps', 'load', 'loads', 'JSONDecoder', 'JSONDecodeError', 'JSONEncoder']
json 模块中常用的函数和类的功能如下：
- json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)：将 obj 对象转换成 JSON 字符串输出到 fp 流中，fp 是一个支持 write() 方法的类文件对象。
- json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan= True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)：将 obj 对象转换为 JSON 字符串，并返回该JSON 字符串。
- json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)：从 fp 流读取 JSON 字符串，将其恢复成 JSON 对象，其中 fp 是一个支持 write() 方法的类文件对象。
- json.loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)：将 JSON 字符串 s 恢复成 JSON 对象。
Python re正则表达式模块及其用法
实际上，掌握 Python 的正则表达式并不难，无非就是几个简单的函数。在 Python 的交互式解释器中先导入 re 模块，然后输入 re.__all__ 命令，即可看到该模块所包含的全部属性和函数：
>>> re.__all__
['match', 'fullmatch', 'search', 'sub', 'subn', 'split', 'findall', 'finditer', 'compile', 'purge', 'template', 'escape', 'error', 'A', 'I', 'L', 'M', 'S', 'X', 'U', 'ASCII', 'IGNORECASE', 'LOCALE', 'MULTILINE', 'DOTALL', 'VERBOSE', 'UNICODE']
从上面的输出结果可以看出，re 模块包含了为数不多的几个函数和属性（用于控制正则表达式匹配的几个选项）。下面先介绍这些函数的作用：
- re.compile(pattern, flags=0)：该函数用于将正则表达式字符串编译成 _sre.SRE_Pattern 对象，该对象代表了正则表达式编译之后在内存中的对象，它可以缓存并复用正则表达式字符串。如果程序需要多次使用同一个正则表达式字符串，则可考虑先编译它。
该函数的 pattern 参数就是它所编译的正则表达式字符串，flags 则代表了正则表达式的匹配旗标。编译得到的 _sre.SRE_Pattern 对象包含了 re 模块中绝大部分函数对应的方法。比如下面两行代码表示先编译正则表达式，然后调用正则表达式的 search() 方法执行匹配：
re.match(pattern, string, flags=0)：尝试从字符串的开始位置来匹配正则表达式，如果从开始位置匹配不成功，match() 函数就返回 None 。其中 pattern 参数代表正则表达式；string 代表被匹配的字符串；flags 则代表正则表达式的匹配旗标。该函数返回 _sre.SRE_Match 对象，该对象包含的 span(n) 方法用于获取第 n+1 个组的匹配位置，group(n) 方法用于获取第 n+1 个组所匹配的子串。 re.search(pattern, string, flags=0)：扫描整个字符串，并返回字符串中第一处匹配 pattern 的匹配对象。其中 pattern 参数代表正则表达式；string 代表被匹配的字符串；flags 则代表正则表达式的匹配旗标。该函数也返回 _sre.SRE_Match 对象。 根据上面介绍不难发现，match() 与 search() 的区别在于，match() 必须从字符串开始处就匹配，但 search() 可以搜索整个字符串 re.findall(pattern, string, flags=0)：扫描整个字符串，并返回字符串中所有匹配 pattern 的子串组成的列表。其中 pattern 参数代表正则表达式；string 代表被匹配的宇符串；flags 则代表正则表达式的匹配旗标。 re.finditer(pattern, string, flags=0)：扫描整个字符串，并返回字符串中所有匹配 pattern 的子串组成的迭代器，迭代器的元素是 _sre.SRE_Match 对象。其中 pattern 参数代表正则表达式；string 代表被匹配的字符串；flags 则代表正则表达式的匹配旗标。
import re
m1 = re.match('www', 'www.fkit.org')# 开始位置可以匹配
print(m1.span()) # span返回匹配的位置
print(m1.group()) # group返回匹配的组
print(re.match('fkit', 'www.fkit.com')) # 开始位置匹配不到，返回None
m2 = re.search('www', 'www.fkit.org') # 开始位置可以匹配
print(m2.span())
print(m2.group())
m3 = re.search('fkit', 'www.fkit.com') # 中间位置可以匹配，返回Match对象
print(m3.span())
print(m3.group())
# 返回所有匹配pattern的子串组成的列表, 忽略大小写
print(re.findall('fkit', 'FkIt is very good , Fkit.org is my favorite' , re.I))
# 返回所有匹配pattern的子串组成的迭代器, 忽略大小写
it = re.finditer('fkit', 'FkIt is very good , Fkit.org is my favorite' , re.I)
for e in it:
print(str(e.start()) + "-->" + e.group())
my_date = '2008-08-18'
# 将my_date字符串里中画线替换成斜线
print(re.sub(r'-', '/' , my_date))
# 将my_date字符串里中画线替换成斜线，只替换一次
print(re.sub(r'-', '/' , my_date, 1))
# 使用逗号对字符串进行分割
print(re.split(', ', 'fkit, fkjava, crazyit'))
# 输出：['fkit', 'fkjava', 'crazyit']
# 指定只分割1次，被切分成2个子串
print(re.split(', ', 'fkit, fkjava, crazyit', 1))
# 输出：['fkit', 'fkjava, crazyit']
# 使用a进行分割
print(re.split('a', 'fkit, fkjava, crazyit'))
# 输出：['fkit, fkj', 'va, crazyit']
# 使用x进行分割，没有匹配内容，则不会执行分割
print(re.split('x', 'fkit, fkjava, crazyit'))
# 输出：['fkit, fkjava, crazyit']
# 对模式中特殊字符进行转义
print(re.escape(r'www.crazyit.org is good, i love it!'))
# 输出：www\.crazyit\.org\ is\ good\,\ i\ love\ it\!
print(re.escape(r'A-Zand0-9?'))
# 输出：A\-Zand0\-9\?
Python set和frozenset集合操作
et 集合是可变容器，程序可以改变容器中的元素。与 set 对应的还有 frozenset 集合，frozenset 是 set 的不可变版本，它的元素是不可变的。
Python set集合
set 集合有如下两个特征：
- set 不记录元素的添加顺序。
- 元素不允许重复。
# 使用花括号构建set集合
c = {'白骨精'}
# 添加元素
c.add("孙悟空")
c.add(6)
print("c集合的元素个数为:" , len(c)) # 输出3
# 删除指定元素
c.remove(6)
print("c集合的元素个数为:" , len(c)) # 输出2
# 判断是否包含指定字符串
print("c集合是否包含'孙悟空'字符串:" , ("孙悟空" in c)) # 输出True
c.add("轻量级Java EE企业应用实战")
print("c集合的元素：" , c)
# 使用set()函数（构造器）来创建set集合
books = set()
books.add("轻量级Java EE企业应用实战")
books.add("疯狂Java讲义")
print("books集合的元素：" , books)
# issubset()方法判断是否为子集合
print("books集合是否为c的子集合？", books.issubset(c)) # 输出False
# issubset()方法与<=运算符效果相同
print("books集合是否为c的子集合？", (books <= c)) # 输出False
# issuperset()方法判断是否为父集合
# issubset和issuperset其实就是倒过来判断
print("c集合是否完全包含books集合？", c.issuperset(books)) # 输出False
# issuperset()方法与>=运算符效果相同
print("c集合是否完全包含books集合？", (c >= books)) # 输出False
# 用c集合减去books集合里的元素，不改变c集合本身
result1 = c - books
print(result1)
# difference()方法也是对集合做减法，与用-执行运算的效果完全一样
result2 = c.difference(books)
print(result2)
# 用c集合减去books集合里的元素，改变c集合本身
c.difference_update(books)
print("c集合的元素：" , c)
# 删除c集合里的所有元素
c.clear()
print("c集合的元素：" , c)
# 直接创建包含元素的集合
d = {"疯狂Java讲义", '疯狂Python讲义', '疯狂Kotlin讲义'}
print("d集合的元素：" , d)
# 计算两个集合的交集，不改变d集合本身
inter1 = d & books
print(inter1)
# intersection()方法也是获取两个集合的交集，与用&执行运算的效果完全一样
inter2 = d.intersection(books)
print(inter2)
# 计算两个集合的交集，改变d集合本身
d.intersection_update(books)
print("d集合的元素：" , d)
# 将range对象包装成set集合
e = set(range(5))
f = set(range(3, 7))
print("e集合的元素：" , e)
print("f集合的元素：" , f)
# 对两个集合执行异或运算
xor = e ^ f
print('e和f执行xor的结果：', xor)
# 计算两个集合的并集，不改变e集合本身
un = e.union(f)
print('e和f执行并集的结果：', un)
# 计算两个集合的并集，改变e集合本身
e.update(f)
print('e集合的元素：', e)
上面程序基本示范了 set 集合中所有方法的用法。不仅如此，该程序还示范了 set 集合支持的如下几个运算符： <=：相当于调用 issubset() 方法，判断前面的 set 集合是否为后面的 set 集合的子集合。 >=：相当于调用 issuperset() 方法，判断前面的 set 集合是否为后面的 set 集合的父集合。 -：相当于调用 difference() 方法，用前面的 set 集合减去后面的 set 集合的元素。 &：相当于调用 intersection() 方法，用于获取两个 set 集舍的交集。 ^：计算两个集合异或的结果，就是用两个集合的并集减去交集的元素。 此外，由于 set 集合本身是可变的，因此它除了提供 add()、remove()、discard() 方法来操作单个元素，还支持进行集合运算来改变集合内的元素。因此，它的集合运算方法都有两个版本： 交集运算：intersection() 和 intersection_update()，前者不改变集合本身，而是返回两个集合的交集；后者会通过交集运算改变第一个集合。 并集运算：union() 和 update()，前者不改变集合本身，而是返回两个集合的并集；后者会通过并集运算改变第一个集合。 减法运算：difference() 和 difference_update()，前者不改变集合本身，而是返回两个集合做咸法的结果；后者改变第一个集合。