pythonds模块_Python的模块

1.系统内置模块

import os

import re

import json

2.序列化模块

序列化是指可以把python中的数据，以文本或二进制的方式进行转换，并且还能反序列化为原来的数据

pickle 序列化

dumps() 序列化，可以把一个python的任意对象序列化成为一个二进制

返回一个序列化后的二进制数据

pickle.dumps(var)

loads() 反序列化，可以把一个序列化后的二进制数据反序列化为python的对象

返回一个反序列化后的python对象

pickle.dumps(var)

dump() 序列化，把一个数据对象进行序列化并写入到文件中

参数1，需要序列化的数据对象

参数2，写入的文件对象

pickle.dump(var,fp)

load() 发序列化，在一个文件中读取序列化的数据，并且完成一个反序列化

参数1，读取的文件对象

pickle.load(fp)

json 序列化

JSON (JavaScript Object Notation) JSON 是一个受 JavaScript 的对象字面量语法启发的轻量级数据交换格式。 JSON 在js语言中是一个对象的表示方法，和Python中的字典的定义规则和语法都很像 JSON 在互联网中又是一种通用的数据交换，数据传输，数据定义的一种数据格式

json.dumps() 完成json格式数据的序列化

json.loads() 完成json格式数据的反序列化

json.dump() 和pickle模块的dump方法一样

json.load() 和pickle模块的load方法一样

3.数学模块 Math

import math

# math的一部分相关函数

# math.ceil() 向上取整,内置函数

res = math.ceil(2.55)

#round(2.24)round() 四舍五入

res = round(2.24)

# math.floor() 向下取整，

res = math.floor(2.55)

# math.pow() 计算数值的n次方,结果是浮点

res = math.pow(2,3)

# math.sqrt() 开平方运算，结果是浮点

res = math.sqrt(12)

# math.fabs() 计算绝对值,结果是浮点

res = math.fabs(-3.14)

# math.modf() 把一个数值拆分成小数和整数组成的元组

res = math.modf(3) #(0.0, 3.0)

# math.copysign(x,y) 把第二个参数的正负符合拷贝给第一个参数,结果为浮点数

res = math.copysign(-3,99)#看第二个数是否正负#3

res = math.copysign(3,-99)#-3

# math.fsum() 将一个容器类型数据中的元素进行一个求和运算，结果为浮点数

res = math.fsum('123') # X TypeError: must be real number, not str

res = math.fsum({1,2,3}) # 注意：容器中的元素必须是可以运算的number类型#6.0

# math.factorial(x) 以一个整数返回 x 的阶乘

res = math.factorial(4) # 4！

# 常量

# 数学常数 π = 3.141592...，精确到可用精度。

res = math.pi

print(res)

4.随机模块 random

import random

# random.random() 返回 [0 , 1) 之间的随机小数 (左闭右开)

res = random.random()

# random.randrange([开始值]，结束值，[步进值]) 随机获取指定范围内的整数

res = random.randrange(5) # 一个参数，从0到5之间的值，左闭右开，随机取一个整数

res = random.randrange(5,10) # 两个参数，从5到10之间的随机数，左闭右开，随机取一个整数

res = random.randrange(5,10,2) # 三个参数，按照指定步进值从第一个值到第二个值之间的随机数，左闭右开

# 随机数的应用场景：数字验证码，高并发下的订单号。。。

# random.randint() 随机产生指定范围内的随机整数

res = random.randint(5,10)

# random.uniform() 获取指定返回内的随机小数

res = random.uniform(5,10)

# random.choice() 随机获取容器类型中的值

res = random.choice('123')

res = random.choice([1,2,3,4])

# random.shuffle() 随机打乱当前列表中的值,没有返回值，直接打乱原数据

arr = [1,2,3,4,5]

res = random.shuffle(arr)#None

print(res,arr)

5.os 操作系统接口模块

import os

# os.getcwd() 获取当前的工作目录,注意获取的不是当前脚本的目录，是python执行这个程序的目录

res = os.getcwd()

# 如果在当前目录执行这个脚本文件，那么getcwd获取的就是当前的文件目录

# 如果把执行的目录切换到其它位置，在执行当前脚本，那么获取的就是你执行这个脚本时的目录

os.chdir() # 修改当前的工作目录

os.chdir('/Users/XXX/Desktop/')

# 修改工作目录后，再去获取工作目录

res = os.getcwd()

# os.listdir() 获取当前或指定目录中的所有项(文件，文件夹，隐藏文件)，组成的列表

res = os.listdir() # 不指定目录时，默认为当前的工作目录 == linux 中的 ls -al == windows dir

res =os.listdir(path='/users/XXX/Desktop/kkb') # == linux 中的 ls -al == windows dir

print(res)

# os.mkdir(文件夹路径，权限) # 创建文件夹

os.mkdir('aa',0o777) # 默认在工作目录创建一个人文件夹

'''

关于系统中的文件权限，仅限linux系统

drwxr-xr-x 4 shoutensakai staff 128 11 27 11:40 aa

dr----x--x 2 shoutensakai staff 64 11 27 11:42 abc

第一位 d代表是一个目录，如果是-则表示为一个文件

前三位的rwx 代表文件所有人( u )的权限

中间三位的 r-x 代表文件所属组( g )的权限

最后三位的 r-x 代表其他人( o )的权限

其中 r w x 代表不同的操作权限 777 分别代表 所有人，所属组，和其它

r 表示是否可读， 4

w 表示是否可写 2

x 表示是否可执行 1

'''

os.mkdir('/users/XXX/Desktop/code/abc/a/b/c') # 不能递归创建

os.makedirs() 可以递归创建文件夹

os.makedirs('/Users/XXX/Desktop/code/abc/a/b/c/')

print(res)

6.os.path 路径模块

import os

os.rmdir() 删除 空 文件夹

os.rmdir('./a') # a 是一个空文件夹

os.rmdir('./b') # b 是 含有一个文件夹的 目录 OSError: Directory not empty: './b'

os.rmdir('./c') # c 是 含有一个文件的 目录 OSError: [Errno 66] Directory not empty: './c'

os.removedirs() 递归删除空文件夹

os.remove() 删除文件

os.remove('./abc/.DS_Store')#找到隐藏文件去删掉

os.rename() 修改文件或文件夹的名字

os.rename('./a','./AAA')

# os.system() 执行操作系统中的命令

os.system('python3 XXX.py')

os.system('ls')

# 将相对路径转化为绝对路径 ***

res = os.path.abspath('./') # /Users/XXX/Desktop/文件夹

# 获取路径中的主体部分 就是返回路径中的最后一部分

res = os.path.basename('/Users/XXX/Desktop/文件夹') # 文件夹

res = os.path.basename('/Users/XXX/Desktop/文件夹/1.py') # 1.py

# 获取路径中的路径部分 返回路径中最后一部分之前的内容

res = os.path.dirname('/Users/XXX/Desktop/文件夹/1.py') # /Users/XXX/Desktop/文件夹

# join() 链接多个路径，组成一个新的路径

res = os.path.join('./a/b/c/','2.jpg') #./a/b/c/2.jpg

# split() 拆分路径，把路径拆分为路径和主体部分，

res = os.path.split('./abc/def/aaa') # ('./abc/def', 'aaa')

# splitext() 拆分路径，可以拆分文件后缀名

res = os.path.splitext('./a/b/c/2.jpg')#('./a/b/c','2.jpg')

# 获取文件的大小 字节数

res = os.path.getsize('./某某某.py')

# 检测是否是一个文件夹,是否存在

res = os.path.isdir('/Users/XXX')

# 检测文件是否存在 ***

res = os.path.isfile('./某某某.py')

# exists() **** 检测路径是否存在，既可以检测文件，也可以检测路径

res = os.path.exists('/Users/XXX/Desktop/文件夹/某某某.py')#True

a = '/Users/XXX/Desktop/文件夹/某某某.py'

b = '/Users/XXX/../XXX/Desktop/文件夹/某某某.py'

# 检测两个path路径是否同时指向了一个目标位置 (两个路径必须真实)

res = os.path.samefile(a,b)

print(res)

7.时间模块

import time

'''

概念：

1。 时间戳： 1574905882.6581771 表示从1970年1月1日0时0分0秒到现在的一个秒数，目前可以计算到2038年

2。 时间字符串： Thu Nov 28 09:54:08 2019

3。 时间元组： time.struct_time(tm_year=2019, tm_mon=11, tm_mday=28, tm_hour=9, tm_min=55, tm_sec=32, tm_wday=3, tm_yday=332, tm_isdst=0)

'''

# 1. 获取当前系统的时间戳

res = time.time()

# 2. 获取当前系统时间，时间字符串

res = time.ctime()

# 3. 获取当前系统时间， 时间元组

res = time.localtime()

# 4. 以上时间字符串和时间元组可以通过指定的时间戳来获取

t = 1564000082.6581771

res = time.ctime(t)

res = time.localtime()

# 5. 使用localtime方法获取的时间元组，如何格式化成为 xxxx年xx月xx日 时：分：秒 星期几

print(f'{res.tm_year}年{res.tm_mon}月{res.tm_mday}日 {res.tm_hour}：{res.tm_min}：{res.tm_sec} 星期{res.tm_wday+1}')

# 6. strftime() 格式化时间 年-月-日 时：分：秒 星期几

res = time.strftime('%Y-%m-%d %H:%M:%S %w')

# 7. sleep(秒) 在给定的秒数内暂停调用线程的执行。该参数可以是浮点数，以指示更精确的睡眠时间。

# print(time.strftime('%Y-%m-%d %H:%M:%S %w'))

# time.sleep(3)

# print(time.strftime('%Y-%m-%d %H:%M:%S %w'))

# 8.计算程序的运行时间

# time.perf_counter()

# 100万次的字符串比较 需要执行的时间

start = time.perf_counter()

for i in range(1000000):

if 'abc' > 'acd':

pass

end = time.perf_counter()

print(end-start) # 0.14171751

#

start = time.perf_counter()

for i in range(1000000):

if 103 > 100 :

pass

end = time.perf_counter()

print(end-start) # 0.164985942