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