python 常见模块

Python sys模块用法详解

sys 是一个和 Python 解释器关系密切的标准库,它和帮助我们访问和 Python 解释器联系紧密的变量和函数

表 1 sys模块常用成员及功能
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

 

表 1 os模块常用变量和函数
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 对象。该函数通过操作系统特定的随机性来源返回随机字节,该随机字节通常是不可预测的,因此适用于绝大部分加密场景。

 

 

表 2 os进程管理函数
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 所示的常用函数。

 

表 1 random模块常用函数
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。

 

[email protected] 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))


[[email protected] sys]
#

 

 

Python time模块详解

 time 模块主要包含各种提供日期、时间功能的类和函数。该模块既提供了把日期、时间格式化为字符串的功能,也提供了从字符串恢复日期、时间的功能。

在 time 模块内提供了一个 time.struct_time 类,该类代表一个时间对象,它主要包含 9 个属性,每个属性的信息如表 1 所示:

表 1 time.struct_time 类中各属性的含义
字段名 字段含义
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 所示:

表 3 JSON 类型转换Python 类型的对应关系
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 所示:

表 4 Python 类型转换 JSON 类型的对应关系
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(rwww.crazyit.org is good, i love it!))
# 输出:www\.crazyit\.org\ is\ good\,\ i\ love\ it\!
print(re.escape(rA-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(),前者不改变集合本身,而是返回两个集合做咸法的结果;后者改变第一个集合。
相关文章
相关标签/搜索