Python常用模块_python常用模块大全

1.re模块

1.1 正则表达式符号：

1.2 正则表达式注意事项

1 字符集
    作用：使用中括号来括住字符串来创建字符集，字符集可匹配他包括的任意字串
        1）‘[pj]ython’ 只能够匹配‘python’ ‘jython’
        2） ‘[a-z]’ 能够（按字母顺序）匹配a-z任意一个字符
        3）‘[a-zA-Z0-9]’ 能匹配任意一个大小写字母和数字
        4）‘[^abc]’ 可以匹配任意除a,b和c 之外的字符串

2 可选项和重复子模式
    作用：在子模式后面加上问号，它就变成可选项，出现或者不出现在匹配字符串中都是合法的,例如：r’(aa)?(bb)?ccddee’ 只能匹配下面几种情况;

‘aabbccddee’
‘aaccddee’
‘bbccddee’
‘ccddee’
1
2
3
4

3 字符串的开始和结尾
    1） ‘w+’ 匹配以w开通的字符串
    2） ‘^http’ 匹配以’http’ 开头的字符串
    3）‘ $com’ 匹配以‘com’结尾的字符串

1.3 常用的re函数：

⒈ re.compile(pattern[, flags])

    1）把一个正则表达式pattern编译成正则对象，以便可以用正则对象的match和search方法
    2）用了re.compile以后，正则对象会得到保留，这样在需要多次运用这个正则对象的时候，效率会有较大的提升

代码实例：

import re
trace_message = "<idle>-0     (-----) [004] .... 2628922.673375: cpu_idle: state=0 cpu_id=4"
cpu_re = re.compile(r'^(.*?)\s+\((.*?)\)\s+\[(.*?)\]\s+\.\.\.\.\s(.*?):\s+(.*?)$')
ret = re.match(cpu_re,log_message)
print(ret)            # <re.Match object; span=(0, 74), match='<idle>-0     (-----) [004] .... 2628922.673375: c>
match='cpu_idle'
1
2
3
4
5
6

⒉ search(pattern, string[, flags]) 和 match(pattern, string[, flags])

    1）match ：只从字符串的开始与正则表达式匹配，匹配成功返回matchobject，否则返回none；
    2）search ：将字符串的所有字串尝试与正则表达式匹配，如果所有的字串都没有匹配成功，返回none，否则返回matchobject；

match与search使用比较代码实例：

import re
a =re.match('.android.camera', '.android.camera-10011 (10011) [007] .... 105371.125644: tracing_mark_write: S|10011|deliverInputEvent|662016339')
b = re.match('deliverInputEvent', '.android.camera-10011 (10011) [007] .... 105371.125644: tracing_mark_write: S|10011|deliverInputEvent|662016339')
print(a.group())                                # .android.camera
print(b)                                        # None

# 无论有多少个匹配的只会匹配一个
c = re.search('camera', '<...>-2994  ( 1347) [002] .... 105367.330952: tracing_mark_write: B|1347|startActivity com.android.camera/.CameraActivity')
print(c)                                        # <re.Match object; span=(99, 105), match='camera'>
match='camera'
print(c.group())                                # camera
1
2
3
4
5
6
7
8
9
10
11

⒊ split(pattern, string[, maxsplit=0])

    作用：将字符串以指定分割方式，格式化成列表

代码实例：

import re
text = 'xx 0xdd###ccTv-1'
print(re.split('\W+', text))     
print(re.split('\W', text))     
print(re.split('\d', text))     
print(re.split('#', text))     
print(re.split('#+', text))  
1
2
3
4
5
6
7

⒋ findall(pattern, string)

    作用：正则表达式 re.findall 方法能够以列表的形式返回能匹配的子串

import re
pattern = r'^(.*?)\s+\((.*?)\)\s+\[(.*?)\]\s+\.\.\.\.\s(.*?):\s+(.*?)$'
trace_str = "<idle>-0     (-----) [004] .... 2628922.673375: cpu_idle: state=0 cpu_id=4"
match = re.findall(pattern, trace_str)
print(match)
# 输出结果：[('<idle>-0', '-----', '004', '2628922.673375', 'cpu_idle: state=0 cpu_id=4')]
1
2
3
4
5
6

⒌ sub(pat, repl, string[, count=0])

    1）替换，将string里匹配pattern的部分，用repl替换掉，最多替换count次然后返回替换后的字符串
    2）如果string里没有可以匹配pattern的串，将被原封不动地返回
    3）repl可以是一个字符串，也可以是一个函数
    4） 如果repl是个字符串，则其中的反斜杆会被处理过，比如 \n 会被转成换行符，反斜杆加数字会被替换成相应的组，比如 \6 表示pattern匹配到的第6个组的内容

⒍ escape(string)

    1） re.escape(pattern) 可以对字符串中所有可能被解释为正则运算符的字符进行转义的应用函数。
    2） 如果字符串很长且包含很多特殊技字符，而你又不想输入一大堆反斜杠，或者字符串来自于用户(比如通过raw_input函数获取输入的内容)，且要用作正则表达式的一部分的时候，可以用这个函数

使用注意事项：
    1.re匹配忽略大小写，匹配换行

import re
#匹配时忽略大小写
print(re.search("[a-z]+","abcdA").group())                      #abcd
print(re.search("[a-z]+","abcdA",flags=re.I).group())           #abcdA
#连同换行符一起匹配：
#'.'默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
print(re.search(r".+","\naaa\nbbb\nccc").group())               #aaa
print(re.search(r".+","\naaa\nbbb\nccc",flags=re.S))            #bbb
        #<_sre.SRE_Match object; span=(0, 12), match='\naaa\nbbb\nccc'>
print(re.search(r".+","\naaa\nbbb\nccc",flags=re.S).group())    #ccc
1
2
3
4
5
6
7
8
9
10

2.init_l=[i for i in re.split(‘(-\d+.\d)’,expression) if i]
    a. 按照类似负数的字符串分割成列表
    b. -\d+.\d是为了可以匹配浮点数（比如：3.14）
    c. （if i）是为了去除列表中的空元素
    d. 分割结果：[‘-1’, ‘-2’, ‘((’, ‘-60’, ‘+30+(’,
3.
re.search(‘[±/(]$’,expression_l[-1])
    a. 匹配expression_l列表最后一个元素是 +,-,,/,( 这五个符号就是负数
4.
new_l=[i for i in re.split(‘([±/()])’,exp) if i]
    a. 将字符串按照+,-,,/,(,)切分成列表（不是正真的负数就切分）
5.
print(re.split(‘([±])’,‘-1+2-3(22+3)‘)) #按照加号或者减号分割成列表
    运行结果： [’', ‘-’, ‘1’, ‘+’, ‘2’, ‘-’, '3(2*2’, ‘+’, ‘3)’]

2. OS模块

代码实例：

import os
#1.获取当前文件路径
print(os.getcwd())
#2 可生成多层递归目录
os.makedirs(r'C:\data\local') # 可以发现在C盘创建了文件夹\data\local
#3 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.removedirs(r'C:\data\local')    # 删除所有空目录
#4 生成单级目录；相当于shell中mkdir dirname
os.mkdir(r'C:\data')        # 仅能创建单个目录
#5 删除空目录(删除非空目录, 使用shutil.rmtree())
os.rmdir(r'C:\data')        # 仅删除指定的一个空目录
#6 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
print(os.listdir(r'C:\vendor\etc\camera'))
#7 删除一个文件
os.remove(r'C:\vendor\etc\camera\camxoverridesettings.txt')        # camxoverridesettings.txt文件
#8 重命名文件/目录
os.rename(r'C:\vendor\etc\camera\cameracamxoverridesettings.txt',r'C:\vendor\camx\src\core\camxsettings.xml')
#9 获取文件/目录信息
print(os.stat(r'C:\vendor\etc\camera\camxoverridesettings.txt'))
#10 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
print(os.sep)                # \
#11 输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
print(os.linesep)
#12 输出用于分割文件路径的字符串
print(os.pathsep)                # ;  （分号）
#13 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
print(os.name)                # nt
#14 运行shell命令，直接显示
os.system("bash command")
#15 获取系统环境变量
print(os.environ) 
#16 返回path规范化的绝对路径
print(os.path.abspath(r'C:\vendor\etc\camera\camxoverridesettings.txt'))    # C:\vendor\etc\camera\camxoverridesettings.txt
#17 将path分割成目录和文件名二元组返回
print(os.path.split(r'C:\vendor\etc\camera'))    # ('C:\\vendor\\etc', 'camera')
#18 返回path的目录。其实就是os.path.split(path)的第一个元素
print(os.path.dirname(r'C:\vendor\etc\camera'))    # C:\vendor\etc
#19 返回文件路径的文件名部分，如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
print(os.path.basename(r'C:\vendor\etc\camera'))    # camera
#20 如果path存在，返回True；如果path不存在，返回False
print(os.path.exists(r'C:\vendor\etc\camera'))    # True
#21 如果path是绝对路径，返回True        # True
print(os.path.isabs(r"C:\vendor\etc\camera"))
#22 如果path是一个存在的文件，返回True。否则返回False
print(os.path.isfile(r'C:\vendor\etc\camera\camxoverridesettings.txt'))        # True
#23 如果path是一个存在的目录，则返回True。否则返回False
print(os.path.isdir(r'C:\vendor\etc\camera'))            # True
#24 返回path所指向的文件或者目录的最后访问时间,浮点型
print(os.path.getatime(r'C:\vendor\etc\camera\camxoverridesettings.txt'))
#25 返回path所指向的文件或者目录的最后修改时间,浮点型
print(os.path.getmtime(r'C:\vendor\etc\camera\camxoverridesettings.txt'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

3. shutil模块

3.1.shutil简介

    Python的Shutil模块可以看做是OS模块的补充, shutil模块用于文件和目录的高级处理，提供了支持文件赋值、移动、删除、压缩和解压等功能。

3.2.复制文件

    shutil模块的主要作用是复制文件，实现方式如下：

1.shutil.copyfileobj(file1,file2)覆盖复制

    将file1的内容覆盖file2，file1、file2表示打开的文件对象。

file1=open('cpu0.py','r') #打开源文件
file2=open('cpu1.py','w') #打开目标文件
shutil.copyfileobj(file1,file2) #文件复制，注意没有返回值
1
2
3

2.shutil.copyfile(file1,file2)覆盖复制
    也是覆盖，但是无须打开文件，直接用文件名进行覆盖（其源码还是调用的copyfileobj）

>>> shutil.copyfile('../cpu0.py','./cpu1.py') #用copyfile复制文件
>>> shutil.copyfile('../cpu0.py','./os/cpu1.py') #目标文件的目录不存在会报错
>>> shutil.copyfile('../cpu.py','./') #dst不是文件而是目录会报错
1
2
3

3.shutil.copymode(file1,file2)权限复制
    仅复制文件权限，不更改文件内容、组和用户，无返回对象。

>>> os.system('chmod 777  ../cpu.py') #用shell指令将源文件的读写属性改变
>>> os.system('ls -l ../cpu.py') #打印源文件的属性为-rwxrwxrwx
>>> shutil.copyfile('../cpu.py','./cpu4.py') #用copyfile来复制文件
>>> os.system('ls -l ./cpu4.py') #打印目标文件属性为-rw-r--r--，和源文件不一样
>>> shutil.copymode('../cpu.py','./cpu4.py')#用copymode来复制文件权限
>>> os.system('ls -l ./cpu4.py') #打印目标文件属性为-rwxrwxrwx，和源文件一样
1
2
3
4
5
6

4.shutil.copystart(file1,file2)状态复制
    复制文件的所有状态信息，包括权限、组、用户和时间等，无返回对象。

>>> shutil.copyfile('../cpu.py','./cpu5.py') #复制文件
>>> os.system('ls -l ../cpu.py') #打印源文件信息
>>> os.system('ls -l ./cpu5.py') #打印目标文件信息，权限和时间和源文件不一样
>>> shutil.copystat('../cpu.py','./cpu5.py') #复制文件stat到目标文件
>>> os.system('ls -l ./cpu5.py') #打印目标文件信息，权限和时间和源文件一样
1
2
3
4
5

5.shutil.copy(file1,file2)内容和权限复制
    复制文件的内容和权限，相当于先执行了copyfile再执行了copysmode。

>>> shutil.copy('../cpu.py','./') #复制文件到当前目录，注意dst为目标路径
>>> os.listdir('./') #列出当前目录的文件名信息，cpu.py已创建
>>> shutil.copy('../cpu.py','./cpu2.py') #复制文件并重命名，注意dst为文件名
>>> os.listdir('./') #列出当前目录的文件名信息，cpu2.py已创建
1
2
3
4

6.shutil.copy2(file1,file2)内容和权限复制
    复制文件的内容及所有状态信息，相当于先执行了copyfile再执行了copystart。

>>> shutil.copy('../cpu.py','./cpu2.py') #用copy来复制文件
>>> time.ctime(os.stat('../cpu.py').st_mtime) #返回源文件修改时间
>>> time.ctime(os.stat('./cpu2.py').st_mtime) #返回目标文件修改时间，和源文件不一样
>>> shutil.copy2('../cpu.py','./cpu3.py') #用copy2来复制文件
>>> time.ctime(os.stat('./cpu3.py').st_mtime) #返回目标文件修改时间，和源文件一样
1
2
3
4
5

7.shutil.copytree()递归复制
    递归地复制文件内容及状态信息

>>> shutil.copytree('/kernel/os/cpu','/kernel/os/cpu1',ignore=None,copy_function=shutil.copy)
>>> os.listdir('/kernel/os/cpu1') #列出copy后的文件夹中的文件
>>> shutil.copytree('/home/user/Python','/kernel/os/cpu2',ignore=shutil.ignore_patterns('*.py'),copy_function=shutil.copy2)
'/kernel/os/cpu2'
>>> os.listdir('/kernel/os/cpu2') #copy后的文件名没有"*py"结尾的文件
1
2
3
4
5

3.3.移动文件

    使用函数shutil.move()函数可以递归地移动文件或重命名，并返回目标，若目标是现有目录则src再当前目录移动；若目标已经存在且不是目录，则可能会被覆盖。

>>> shutil.move('cpu0.py','cpu1.py') #移动文件
>>> shutil.move('./cpu0','./cpu1') #移动文件夹
1
2

3.4.读取压缩及归档压缩文件

    使用函数shutil.make_archive()创建归档文件，并返回归档后的名称。

语法如下：

shutil.make_archive(base_name,format[,root_dir[,base_dir[,verbose[,dry_run[,owner[,group[,logger]]]]]]])
1

    1）base_name为需要创建的文件名，包括路径
    2）format表示压缩格式，可选zip、tar或bztar等
    3）root_dir为归档的目录

>>> os.listdir()
['cpu0', 'cpu1.py', 'cpu2.py']
>>> shutil.make_archive('./cpu0','zip','./') #压缩文件为zip格式
'/kernel/cpu0.zip'
1
2
3
4

4. random模块

4.1 主要函数

4.2 代码实例：

import random
#⒈ 随机整数：
print(random.randint(0,99))             # 随机选取0-99之间的整数
print(random.randrange(0, 101, 2))      # 随机选取0-101之间的偶数
#⒉ 随机浮点数：
print(random.random())                   # 0.972654134347
print(random.uniform(1, 10))             # 4.14709813772
#⒊ 随机字符：
print(random.choice('abcdefg'))         # c
print(random.sample('abcdefghij',3))    # ['j', 'f', 'c']
1
2
3
4
5
6
7
8
9
10

5. data，datetime，time模块

5.1 data模块

5.1.1 主要函数：

5.2 datetime模块

5.2.1 主要函数：

5.3 time()模块

5.3.1 重要函数

5.3.2 代码实例：

import time
print(time.time())                              # 时间戳：1511166937.2178104
print(time.strftime('%Y-%m-%d'))                # 格式化的字符串: 2017-11-20
print(time.localtime())                         # 结构化时间(元组): 
(tm_year=2017, tm_mon=11...)
print(time.gmtime())                            # 将时间转换成utc格式的元组格式： 
(tm_year=2017, tm_mon=11...)
#1. 将结构化时间转换成时间戳： 1511167004.0
print(time.mktime(time.localtime()))
#2. 将格字符串时间转换成结构化时间 元组： (tm_year=2017, tm_mon=11...)
print(time.strptime('2014-11-11', '%Y-%m-%d'))
#3. 结构化时间(元组) 转换成  字符串时间  ：2017-11-20
print(time.strftime('%Y-%m-%d', time.localtime()))  # 默认当前时间
#4. 将结构化时间(元组) 转换成英文字符串时间 : Mon Nov 20 16:51:28 2017
print(time.asctime(time.localtime()))
#5. 将时间戳转成 英文字符串时间 : Mon Nov 20 16:51:28 2017
print(time.ctime(time.time()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6. sys模块

import sys
# 1. sys.argv：传递给Python脚本的命令行参数列表，第一个参数是程序本身的路径，实现了从程序外部向程序内传递参数。
print("命令行参数如下：")
for i in sys.argv:
    print(i)
# 2. sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 
print(sys.path)
import sys
#3. sys.exit() 退出程序, 正常退出时为sys.exit(0)
def f(value):
    print(value)
    sys.exit(0)
print("hello")
try:
    sys.exit(1)
except SystemExit as value:
    f(value)
print("world")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.查找器和加载器

在sys模块中，有一个成员变量sys.modules，类型为字典，键值分别为python中各模块的名字和模块本身。
sys.modules.keys() 返回所有已经导入的模块列表
sys.modules 返回系统导入的模块字段，key是模块名，value是模块

import sys
for key in sys.modules:
    print(key,sys.modules[key])
1
2
3

sys.exc_info() # 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n) # 退出程序，正常退出时exit(0)
sys.hexversion # 获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version # 获取Python解释程序的版本信息
sys.platform # 返回操作系统平台名称
sys.stdout 标准输出
sys.stdout.write(‘aaa‘) 标准输出内容
sys.stdout.writelines() 无换行输出
sys.stdin 标准输入
sys.stdin.read() 输入一行
sys.stderr 错误输出
sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息 
sys.exec_prefix 返回平台独立的python文件安装的位置 
sys.byteorder 本地字节规则的指示器，big-endian平台的值是‘big‘,little-endian平台的值是‘little‘ 
sys.copyright 记录python版权相关的东西 
sys.api_version 解释器的C的API版本 
sys.version_info ‘final‘表示最终,也有‘candidate‘表示候选，表示版本级别，是否有后继的发行 
sys.getdefaultencoding() 返回当前你所用的默认的字符编码格式 
sys.getfilesystemencoding() 返回将Unicode文件名转换成系统文件名的编码的名字 
sys.builtin_module_names Python解释器导入的内建模块列表 
sys.executable Python解释程序路径 
sys.getwindowsversion() 获取Windows的版本 
sys.stdin.readline() 从标准输入读一行，sys.stdout.write(“a”) 屏幕输出a
sys.setdefaultencoding(name) 用来设置当前默认的字符编码(详细使用参考文档) 
sys.displayhook(value) 如果value非空，这个函数会把他输出到sys.stdout(详细使用参考文档)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

7. string模块

代码实例：

1.字符串格式输出对齐

str = "<idle>-0 (-----) [002] d..1 105367.656356: cpu_idle: state=0 cpu_id=2" 
print(str.center(20))           #生成20个字符长度，str排中间
print(str.ljust(20))            #生成20个字符长度，str左对齐
print(str.rjust(20))            #生成20个字符长度，str右对齐
1
2
3
4

2.大小写转换

str = "CamX : [ERROR][FD] camxfdmanagernode.cpp"
print(str.upper())               #转大写
print(str.lower())               #转小写
print(str.capitalize())           #字符串首为大写，其余小写
print(str.swapcase())              #大小写对换
print(str.title())               #以分隔符为标记，首字符为大写，其余为小写
1
2
3
4
5
6

3.字符串条件判断

str = '01234'
print(str.isalnum())               #是否全是字母和数字，并至少有一个字符
print(str.isdigit() )              #是否全是数字，并至少有一个字符
str = 'string'
print(str.isalpha() )              #是否全是字母，并至少有一个字符
print(str.islower() )              #是否全是小写，当全是小写和数字一起时候，也判断为True
str = ' '
print(str.isspace() )              #是否全是空白字符，并至少有一个字符
str = 'ABC'
print(str.isupper() )              #是否全是大写，当全是大写和数字一起时候，也判断为True
str = 'Aaa Bbb'
print(str.istitle() )              #所有单词字首都是大写，标题
str = 'string learn'
print(str.startswith('str'))       #判断字符串以'str'开头
print(str.endswith('arn') )        #判读字符串以'arn'结尾
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.字符串搜索定位与替换

str='CamX : [ERROR][CHI ] camxchinodewrapper.cpp:3490 ExecuteProcessRequest() Node::ZSLPreviewRaw'
print(str.find('z') )      #查找字符串，没有则返回-1，有则返回查到到第一个匹配的索引
print(str.rfind('n'))      #返回的索引是最后一次匹配的
print(str.index('a'))      #如果没有匹配则报错
print(str.rindex("n"))     #返回最后一次匹配的索引值
print(str.count('n'))      #字符串中匹配的次数
print(str.replace('EAR','ear') )       #匹配替换
print(str.strip('n'))       #删除字符串首尾匹配的字符，通常用于默认删除回车符
print(str.lstrip('n'))      #左匹配
print(str.rstrip('n'))      #右匹配
print(str.expandtabs())     #把制表符转为空格
1
2
3
4
5
6
7
8
9
10
11

5.字符串编码与解码

str = "camera性能优化学习"
print(str.decode('utf-8'))                              #解码过程，将utf-8解码为unicode
print(str.decode("utf-8").encode('gbk'))                #编码过程，将unicode编码为gbk
print(str.decode('utf-8').encode('utf-8'))              #将unicode编码为utf-8
1
2
3
4

6.字符串分割变换

str = "kernel performance optimization"
print('-'.join(str))
list_str = ['kernel','performance','optimization']
print('-'.join(list_str))
print(str.split('n'))
print(str.split('n',1))
print(str.rsplit('n'))
print(str.rsplit('n',1))
print(str.splitlines())
print(str.partition('n'))
print(str.rpartition('n'))
1
2
3
4
5
6
7
8
9
10
11

8. math模块

8.1 math模块是python中用来处理常见的数学计算。

8.2 代码实例：

8.2.1 math模块中的常量

import math
print('\t1. 圆周率π：', math.pi)
print('\t2. 圆周常数Tau(2π)：', math.tau)
print('\t3. 自然常数e：', math.e)
print('\t4. 浮点数无穷大inf：', math.inf)
print('\t5. 非数值nan：', math.nan)
1
2
3
4
5
6

8.2.2 通用函数

import math
print('\t1. ceil获取大于或等于输入值的最小整数（向上取整）：', math.ceil(5.2))
print('\t2. floor获取小于或等于输入值的最大整数（向下取整）：', math.floor(5.2))
print('\t3. fabs获取输入值的绝对值：', math.fabs(-5.2))
print('\t4. factorial获取输入值的阶乘：', math.factorial(5))
print('\t5. gcd获取输入值x和y的最大公约数：', math.gcd(40, 60))
print('\t6. modf获取输入值的小数和整数部分：', math.modf(5.2))
print('\t7. fmod获取输入值x对y取模，x-n*y其中n=math.floor(x/y)：', math.fmod(5.2, 2))
print('\t8. remainder获取输入值x相对于y的余数，x-n*y其中n=math.ceil(x/y)：', math.remainder(5.2, 2))
print('\t9. copysign获取输入值x的绝对值和输入值y的符号：', math.copysign(5.2, -1))
print('\t10. frexp返回一个元组(x,y),使得输入值=x*2**y：', math.frexp(5.2))
print('\t11. ldexp根据输入值x和y，返回x*(2**y)：', math.ldexp(0.65, 3))
print('\t12. fsum返回可迭代对象中的迭代和：', math.fsum([1.2, 5.2, 3.0]))
print('\t13. trunc返回输入值x的整数部分：', math.trunc(5.2))
print('\t14. isclose判断浮点数是否接近，默认相对误差为1e-9：', math.isclose(5.20000001, 5.20000002))
print('\t15. isfinite判断输入值是否是有限数值：', math.isfinite(5.2))
print('\t16. isinf判断输入值是否是正或者负无穷：', math.isinf(-math.inf))
print('\t17. isnan判断输入值是否是非数值类型：', math.isnan(5.2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

8.2.3 幂函数与对数函数相关操作

import math
print('\t1. exp获取e的x次幂：', math.exp(2))
print('\t2. expm1获取e的x次幂减1：', math.expm1(2))
print('\t3. log获取x的对数，默认底为e：', math.log(2))
print('\t4. log1p获取1加x的自然对数（底为e）：', math.log1p(1))
print('\t5. log2获取x以2的对数，比math.log(x,2)更加精确：', math.log2(3))
print('\t6. log10获取x以10的对数，比math.log(x,10)更加精确：', math.log10(3))
print('\t7. pow获取x的y次幂：', math.pow(2,3))
print('\t8. sqrt获取x的平方根：', math.sqrt(4))
1
2
3
4
5
6
7
8
9

8.2.4 三角函数相关操作

import math
print('\t1. 以弧度为单位返回x的反余弦值：', math.acos(0.5))
print('\t2. 以弧度为单位返回x的反正弦值：', math.asin(0.5))
print('\t3. 以弧度为单位返回x的反正切值：', math.atan(0.5))
print('\t4. 以弧度为单位返回x/y的反余弦值：', math.atan2(1, 2))
print('\t5. 返回x弧度的余弦值：', math.cos(1.0471975511965979))
print('\t6. 返回x弧度的正弦值：', math.sin(0.5235987755982989))
print('\t7. 返回x弧度的正切值：', math.tan(0.4636476090008061))
print('\t8. 返回原点到(x,y)的欧式距离，等于：', math.hypot(3,4))
1
2
3
4
5
6
7
8
9

8.2.5 角度转换相关操作

import math
print('\t1. 弧度转度数：', math.degrees(0.5))
print('\t2. 度数转弧度：', math.radians(28.64788975654116))
1
2
3

8.2.6 双曲函数相关操作

import math
print('\t1. 返回x的反双曲余弦值：', math.acosh(5))
print('\t2. 返回x的反双曲正弦值：', math.asinh(5))
print('\t3. 返回x的反双曲正切值：', math.atanh(0.5))
print('\t4. 返回x的双曲余弦值：', math.cosh(2.2924316695611777))
print('\t5. 返回x的双曲正弦值：', math.sinh(2.3124383412727525))
print('\t6. 返回x的双曲正切值：', math.tanh(0.5493061443340549))
1
2
3
4
5
6
7

8.2.7 其他数学操作

import math
print('\t1. 获取输入值的误差函数：', math.erf(0.67))
print('\t2. 获取输入值的互补误差函数：', math.erfc(0.67))
print('\t3. 获取输入值的伽马函数值：', math.gamma(-0.67))
print('\t4. 获取伽马函数在输入值x的绝对值的自然对数，等价于：', math.lgamma(-0.67))
1
2
3
4
5